AWS Global Accelerator (amazonaws.com) – OpenAPI Spec, Docs & Bruno Collection

POST AddCustomRoutingEndpoints

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AddCustomRoutingEndpoints")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 AdvertiseByoipCidr

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AdvertiseByoipCidr")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 AllowCustomRoutingTraffic

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.AllowCustomRoutingTraffic")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CreateAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CreateCustomRoutingAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CreateCustomRoutingEndpointGroup

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CreateCustomRoutingListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateCustomRoutingListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CreateEndpointGroup

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateEndpointGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CreateListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.CreateListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeleteAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeleteCustomRoutingAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeleteCustomRoutingEndpointGroup

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeleteCustomRoutingListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteCustomRoutingListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeleteEndpointGroup

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteEndpointGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeleteListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeleteListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DenyCustomRoutingTraffic

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DenyCustomRoutingTraffic")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeprovisionByoipCidr

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr"

headers = {"x-amz-target": ""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DeprovisionByoipCidr")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator"

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

	req.Header.Add("x-amz-target", "")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator',
  headers: {'x-amz-target': ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

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

const http = require('https');

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

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

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator',
  headers: {'x-amz-target': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-amz-target': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator',
  headers: {'x-amz-target': ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

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

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-amz-target' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator' -Method POST -Headers $headers

import http.client

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

headers = { 'x-amz-target': "" }

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

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeAcceleratorAttributes

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeAcceleratorAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeCustomRoutingAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeCustomRoutingAcceleratorAttributes

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeCustomRoutingEndpointGroup

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeCustomRoutingListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeCustomRoutingListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeEndpointGroup

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeEndpointGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.DescribeListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListAccelerators

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListAccelerators")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListByoipCidrs

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListByoipCidrs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListCustomRoutingAccelerators

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingAccelerators")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListCustomRoutingEndpointGroups

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListCustomRoutingListeners

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingListeners")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListCustomRoutingPortMappings

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListCustomRoutingPortMappingsByDestination

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListEndpointGroups

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListEndpointGroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListListeners

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListListeners")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListTagsForResource

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ListTagsForResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ProvisionByoipCidr

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.ProvisionByoipCidr")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RemoveCustomRoutingEndpoints

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TagResource

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.TagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UntagResource

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UntagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UpdateAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UpdateAcceleratorAttributes

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateAcceleratorAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UpdateCustomRoutingAccelerator

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UpdateCustomRoutingAcceleratorAttributes

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UpdateCustomRoutingListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateCustomRoutingListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UpdateEndpointGroup

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateEndpointGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UpdateListener

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.UpdateListener")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 WithdrawByoipCidr

{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr

HEADERS

X-Amz-Target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr" {:headers {:x-amz-target ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr"
headers = HTTP::Headers{
  "x-amz-target" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr"),
    Headers =
    {
        { "x-amz-target", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-amz-target", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr")
  .setHeader("x-amz-target", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr"))
    .header("x-amz-target", "")
    .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}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr")
  .header("x-amz-target", "")
  .asString();

const 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}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr');
xhr.setRequestHeader('x-amz-target', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr',
  method: 'POST',
  headers: {
    'x-amz-target': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr")
  .post(null)
  .addHeader("x-amz-target", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.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}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr',
  headers: {'x-amz-target': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr');

req.headers({
  'x-amz-target': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr',
  headers: {'x-amz-target': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr';
const options = {method: 'POST', headers: {'x-amz-target': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr', [
  'headers' => [
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-amz-target' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-amz-target': "" }

conn.request("POST", "/baseUrl/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr"

headers = {"x-amz-target": ""}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr"

response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr' \
  --header 'x-amz-target: '

http POST '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr' \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr'

import Foundation

let headers = ["x-amz-target": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=GlobalAccelerator_V20180706.WithdrawByoipCidr")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

AWS Global Accelerator

AWS Global Acceleratorv2018-08-08

Related APIs