Amazon Cognito Identity Provider

POST AddCustomAttributes

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "CustomAttributes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:UserPoolId ""
                                                                                                                              :CustomAttributes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "UserPoolId": "",
  "CustomAttributes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  CustomAttributes: ''
});

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=AWSCognitoIdentityProviderService.AddCustomAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', CustomAttributes: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","CustomAttributes":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AddCustomAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "CustomAttributes": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', CustomAttributes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', CustomAttributes: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  CustomAttributes: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AddCustomAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', CustomAttributes: ''}
};

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=AWSCognitoIdentityProviderService.AddCustomAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","CustomAttributes":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"CustomAttributes": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'CustomAttributes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AddCustomAttributes', [
  'body' => '{
  "UserPoolId": "",
  "CustomAttributes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserPoolId' => '',
  'CustomAttributes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "CustomAttributes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "CustomAttributes": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes"

payload = {
    "UserPoolId": "",
    "CustomAttributes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"CustomAttributes\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "CustomAttributes": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "CustomAttributes": ""
}'

echo '{
  "UserPoolId": "",
  "CustomAttributes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "CustomAttributes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AddCustomAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "CustomAttributes": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminAddUserToGroup

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:UserPoolId ""
                                                                                                                              :Username ""
                                                                                                                              :GroupName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup"

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

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
  .asString();

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

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=AWSCognitoIdentityProviderService.AdminAddUserToGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', GroupName: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","GroupName":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminAddUserToGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "GroupName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: '', GroupName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', GroupName: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', GroupName: ''}
};

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=AWSCognitoIdentityProviderService.AdminAddUserToGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","GroupName":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"GroupName": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'GroupName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminAddUserToGroup', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'GroupName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup"

payload = {
    "UserPoolId": "",
    "Username": "",
    "GroupName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "GroupName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "GroupName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminAddUserToGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminConfirmSignUp

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:UserPoolId ""
                                                                                                                             :Username ""
                                                                                                                             :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.AdminConfirmSignUp');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', ClientMetadata: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminConfirmSignUp',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "ClientMetadata": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: '', ClientMetadata: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', ClientMetadata: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminConfirmSignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', ClientMetadata: ''}
};

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=AWSCognitoIdentityProviderService.AdminConfirmSignUp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"ClientMetadata": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminConfirmSignUp', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'ClientMetadata' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp"

payload = {
    "UserPoolId": "",
    "Username": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "ClientMetadata": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminConfirmSignUp'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminCreateUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:UserPoolId ""
                                                                                                                          :Username ""
                                                                                                                          :UserAttributes ""
                                                                                                                          :ValidationData ""
                                                                                                                          :TemporaryPassword ""
                                                                                                                          :ForceAliasCreation ""
                                                                                                                          :MessageAction ""
                                                                                                                          :DesiredDeliveryMediums ""
                                                                                                                          :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 222

{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  UserAttributes: '',
  ValidationData: '',
  TemporaryPassword: '',
  ForceAliasCreation: '',
  MessageAction: '',
  DesiredDeliveryMediums: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.AdminCreateUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    Username: '',
    UserAttributes: '',
    ValidationData: '',
    TemporaryPassword: '',
    ForceAliasCreation: '',
    MessageAction: '',
    DesiredDeliveryMediums: '',
    ClientMetadata: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","UserAttributes":"","ValidationData":"","TemporaryPassword":"","ForceAliasCreation":"","MessageAction":"","DesiredDeliveryMediums":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminCreateUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "UserAttributes": "",\n  "ValidationData": "",\n  "TemporaryPassword": "",\n  "ForceAliasCreation": "",\n  "MessageAction": "",\n  "DesiredDeliveryMediums": "",\n  "ClientMetadata": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  UserPoolId: '',
  Username: '',
  UserAttributes: '',
  ValidationData: '',
  TemporaryPassword: '',
  ForceAliasCreation: '',
  MessageAction: '',
  DesiredDeliveryMediums: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    Username: '',
    UserAttributes: '',
    ValidationData: '',
    TemporaryPassword: '',
    ForceAliasCreation: '',
    MessageAction: '',
    DesiredDeliveryMediums: '',
    ClientMetadata: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  UserAttributes: '',
  ValidationData: '',
  TemporaryPassword: '',
  ForceAliasCreation: '',
  MessageAction: '',
  DesiredDeliveryMediums: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminCreateUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    Username: '',
    UserAttributes: '',
    ValidationData: '',
    TemporaryPassword: '',
    ForceAliasCreation: '',
    MessageAction: '',
    DesiredDeliveryMediums: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.AdminCreateUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","UserAttributes":"","ValidationData":"","TemporaryPassword":"","ForceAliasCreation":"","MessageAction":"","DesiredDeliveryMediums":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"UserAttributes": @"",
                              @"ValidationData": @"",
                              @"TemporaryPassword": @"",
                              @"ForceAliasCreation": @"",
                              @"MessageAction": @"",
                              @"DesiredDeliveryMediums": @"",
                              @"ClientMetadata": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'UserAttributes' => '',
    'ValidationData' => '',
    'TemporaryPassword' => '',
    'ForceAliasCreation' => '',
    'MessageAction' => '',
    'DesiredDeliveryMediums' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminCreateUser', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'UserAttributes' => '',
  'ValidationData' => '',
  'TemporaryPassword' => '',
  'ForceAliasCreation' => '',
  'MessageAction' => '',
  'DesiredDeliveryMediums' => '',
  'ClientMetadata' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'UserAttributes' => '',
  'ValidationData' => '',
  'TemporaryPassword' => '',
  'ForceAliasCreation' => '',
  'MessageAction' => '',
  'DesiredDeliveryMediums' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser"

payload = {
    "UserPoolId": "",
    "Username": "",
    "UserAttributes": "",
    "ValidationData": "",
    "TemporaryPassword": "",
    "ForceAliasCreation": "",
    "MessageAction": "",
    "DesiredDeliveryMediums": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"TemporaryPassword\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"MessageAction\": \"\",\n  \"DesiredDeliveryMediums\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "UserAttributes": "",
        "ValidationData": "",
        "TemporaryPassword": "",
        "ForceAliasCreation": "",
        "MessageAction": "",
        "DesiredDeliveryMediums": "",
        "ClientMetadata": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "UserAttributes": "",\n  "ValidationData": "",\n  "TemporaryPassword": "",\n  "ForceAliasCreation": "",\n  "MessageAction": "",\n  "DesiredDeliveryMediums": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminCreateUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ValidationData": "",
  "TemporaryPassword": "",
  "ForceAliasCreation": "",
  "MessageAction": "",
  "DesiredDeliveryMediums": "",
  "ClientMetadata": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminDeleteUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:UserPoolId ""
                                                                                                                          :Username ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "Username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: ''
});

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=AWSCognitoIdentityProviderService.AdminDeleteUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminDeleteUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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=AWSCognitoIdentityProviderService.AdminDeleteUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminDeleteUser', [
  'body' => '{
  "UserPoolId": "",
  "Username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser"

payload = {
    "UserPoolId": "",
    "Username": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": ""
}'

echo '{
  "UserPoolId": "",
  "Username": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminDeleteUserAttributes

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:UserPoolId ""
                                                                                                                                    :Username ""
                                                                                                                                    :UserAttributeNames ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 68

{
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  UserAttributeNames: ''
});

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=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', UserAttributeNames: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","UserAttributeNames":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "UserAttributeNames": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: '', UserAttributeNames: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', UserAttributeNames: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  UserAttributeNames: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', UserAttributeNames: ''}
};

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=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","UserAttributeNames":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"UserAttributeNames": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'UserAttributeNames' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'UserAttributeNames' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'UserAttributeNames' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes"

payload = {
    "UserPoolId": "",
    "Username": "",
    "UserAttributeNames": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributeNames\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "UserAttributeNames": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "UserAttributeNames": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDeleteUserAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "UserAttributeNames": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminDisableProviderForUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "User": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:UserPoolId ""
                                                                                                                                      :User ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "UserPoolId": "",
  "User": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  User: ''
});

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=AWSCognitoIdentityProviderService.AdminDisableProviderForUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', User: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","User":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminDisableProviderForUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "User": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', User: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', User: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  User: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminDisableProviderForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', User: ''}
};

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=AWSCognitoIdentityProviderService.AdminDisableProviderForUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","User":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"User": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'User' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminDisableProviderForUser', [
  'body' => '{
  "UserPoolId": "",
  "User": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserPoolId' => '',
  'User' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "User": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "User": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser"

payload = {
    "UserPoolId": "",
    "User": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"User\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "User": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "User": ""
}'

echo '{
  "UserPoolId": "",
  "User": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "User": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableProviderForUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "User": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminDisableUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:UserPoolId ""
                                                                                                                           :Username ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "Username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: ''
});

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=AWSCognitoIdentityProviderService.AdminDisableUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminDisableUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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=AWSCognitoIdentityProviderService.AdminDisableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminDisableUser', [
  'body' => '{
  "UserPoolId": "",
  "Username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser"

payload = {
    "UserPoolId": "",
    "Username": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": ""
}'

echo '{
  "UserPoolId": "",
  "Username": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminDisableUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminEnableUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:UserPoolId ""
                                                                                                                          :Username ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "Username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: ''
});

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=AWSCognitoIdentityProviderService.AdminEnableUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminEnableUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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=AWSCognitoIdentityProviderService.AdminEnableUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminEnableUser', [
  'body' => '{
  "UserPoolId": "",
  "Username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser"

payload = {
    "UserPoolId": "",
    "Username": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": ""
}'

echo '{
  "UserPoolId": "",
  "Username": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminEnableUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminForgetDevice

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:UserPoolId ""
                                                                                                                            :Username ""
                                                                                                                            :DeviceKey ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  DeviceKey: ''
});

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=AWSCognitoIdentityProviderService.AdminForgetDevice');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', DeviceKey: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","DeviceKey":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminForgetDevice',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "DeviceKey": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: '', DeviceKey: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', DeviceKey: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  DeviceKey: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminForgetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', DeviceKey: ''}
};

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=AWSCognitoIdentityProviderService.AdminForgetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","DeviceKey":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"DeviceKey": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'DeviceKey' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminForgetDevice', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'DeviceKey' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'DeviceKey' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice"

payload = {
    "UserPoolId": "",
    "Username": "",
    "DeviceKey": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "DeviceKey": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "DeviceKey": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminForgetDevice'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminGetDevice

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice

HEADERS

X-Amz-Target

BODY json

{
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:DeviceKey ""
                                                                                                                         :UserPoolId ""
                                                                                                                         :Username ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice"

	payload := strings.NewReader("{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DeviceKey: '',
  UserPoolId: '',
  Username: ''
});

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=AWSCognitoIdentityProviderService.AdminGetDevice');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DeviceKey: '', UserPoolId: '', Username: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeviceKey":"","UserPoolId":"","Username":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminGetDevice',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceKey": "",\n  "UserPoolId": "",\n  "Username": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({DeviceKey: '', UserPoolId: '', Username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DeviceKey: '', UserPoolId: '', Username: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  DeviceKey: '',
  UserPoolId: '',
  Username: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DeviceKey: '', UserPoolId: '', Username: ''}
};

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=AWSCognitoIdentityProviderService.AdminGetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeviceKey":"","UserPoolId":"","Username":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DeviceKey": @"",
                              @"UserPoolId": @"",
                              @"Username": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DeviceKey' => '',
    'UserPoolId' => '',
    'Username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminGetDevice', [
  'body' => '{
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceKey' => '',
  'UserPoolId' => '',
  'Username' => ''
]));

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

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

append(json_encode([
  'DeviceKey' => '',
  'UserPoolId' => '',
  'Username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
}'

import http.client

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

payload = "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice"

payload = {
    "DeviceKey": "",
    "UserPoolId": "",
    "Username": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice"

payload <- "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DeviceKey\": \"\",\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "DeviceKey": "",
        "UserPoolId": "",
        "Username": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
}'

echo '{
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceKey": "",\n  "UserPoolId": "",\n  "Username": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetDevice'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DeviceKey": "",
  "UserPoolId": "",
  "Username": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminGetUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:UserPoolId ""
                                                                                                                       :Username ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "Username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: ''
});

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=AWSCognitoIdentityProviderService.AdminGetUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminGetUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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=AWSCognitoIdentityProviderService.AdminGetUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminGetUser', [
  'body' => '{
  "UserPoolId": "",
  "Username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser"

payload = {
    "UserPoolId": "",
    "Username": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": ""
}'

echo '{
  "UserPoolId": "",
  "Username": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminGetUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminInitiateAuth

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:UserPoolId ""
                                                                                                                            :ClientId ""
                                                                                                                            :AuthFlow ""
                                                                                                                            :AuthParameters ""
                                                                                                                            :ClientMetadata ""
                                                                                                                            :AnalyticsMetadata ""
                                                                                                                            :ContextData ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 154

{
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  AuthFlow: '',
  AuthParameters: '',
  ClientMetadata: '',
  AnalyticsMetadata: '',
  ContextData: ''
});

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=AWSCognitoIdentityProviderService.AdminInitiateAuth');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    AuthFlow: '',
    AuthParameters: '',
    ClientMetadata: '',
    AnalyticsMetadata: '',
    ContextData: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","AuthFlow":"","AuthParameters":"","ClientMetadata":"","AnalyticsMetadata":"","ContextData":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminInitiateAuth',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "AuthFlow": "",\n  "AuthParameters": "",\n  "ClientMetadata": "",\n  "AnalyticsMetadata": "",\n  "ContextData": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  AuthFlow: '',
  AuthParameters: '',
  ClientMetadata: '',
  AnalyticsMetadata: '',
  ContextData: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    ClientId: '',
    AuthFlow: '',
    AuthParameters: '',
    ClientMetadata: '',
    AnalyticsMetadata: '',
    ContextData: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: '',
  AuthFlow: '',
  AuthParameters: '',
  ClientMetadata: '',
  AnalyticsMetadata: '',
  ContextData: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminInitiateAuth',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    AuthFlow: '',
    AuthParameters: '',
    ClientMetadata: '',
    AnalyticsMetadata: '',
    ContextData: ''
  }
};

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=AWSCognitoIdentityProviderService.AdminInitiateAuth';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","AuthFlow":"","AuthParameters":"","ClientMetadata":"","AnalyticsMetadata":"","ContextData":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"",
                              @"AuthFlow": @"",
                              @"AuthParameters": @"",
                              @"ClientMetadata": @"",
                              @"AnalyticsMetadata": @"",
                              @"ContextData": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => '',
    'AuthFlow' => '',
    'AuthParameters' => '',
    'ClientMetadata' => '',
    'AnalyticsMetadata' => '',
    'ContextData' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminInitiateAuth', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'AuthFlow' => '',
  'AuthParameters' => '',
  'ClientMetadata' => '',
  'AnalyticsMetadata' => '',
  'ContextData' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'AuthFlow' => '',
  'AuthParameters' => '',
  'ClientMetadata' => '',
  'AnalyticsMetadata' => '',
  'ContextData' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth"

payload = {
    "UserPoolId": "",
    "ClientId": "",
    "AuthFlow": "",
    "AuthParameters": "",
    "ClientMetadata": "",
    "AnalyticsMetadata": "",
    "ContextData": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "ClientId": "",
        "AuthFlow": "",
        "AuthParameters": "",
        "ClientMetadata": "",
        "AnalyticsMetadata": "",
        "ContextData": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "AuthFlow": "",\n  "AuthParameters": "",\n  "ClientMetadata": "",\n  "AnalyticsMetadata": "",\n  "ContextData": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminInitiateAuth'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": "",
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "AnalyticsMetadata": "",
  "ContextData": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminLinkProviderForUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:UserPoolId ""
                                                                                                                                   :DestinationUser ""
                                                                                                                                   :SourceUser ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 67

{
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  DestinationUser: '',
  SourceUser: ''
});

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=AWSCognitoIdentityProviderService.AdminLinkProviderForUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', DestinationUser: '', SourceUser: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","DestinationUser":"","SourceUser":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminLinkProviderForUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "DestinationUser": "",\n  "SourceUser": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', DestinationUser: '', SourceUser: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', DestinationUser: '', SourceUser: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  DestinationUser: '',
  SourceUser: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminLinkProviderForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', DestinationUser: '', SourceUser: ''}
};

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=AWSCognitoIdentityProviderService.AdminLinkProviderForUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","DestinationUser":"","SourceUser":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"DestinationUser": @"",
                              @"SourceUser": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'DestinationUser' => '',
    'SourceUser' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminLinkProviderForUser', [
  'body' => '{
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'DestinationUser' => '',
  'SourceUser' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'DestinationUser' => '',
  'SourceUser' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser"

payload = {
    "UserPoolId": "",
    "DestinationUser": "",
    "SourceUser": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"DestinationUser\": \"\",\n  \"SourceUser\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "DestinationUser": "",
        "SourceUser": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
}'

echo '{
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "DestinationUser": "",\n  "SourceUser": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminLinkProviderForUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "DestinationUser": "",
  "SourceUser": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminListDevices

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:UserPoolId ""
                                                                                                                           :Username ""
                                                                                                                           :Limit ""
                                                                                                                           :PaginationToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 80

{
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  Limit: '',
  PaginationToken: ''
});

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=AWSCognitoIdentityProviderService.AdminListDevices');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', Limit: '', PaginationToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","Limit":"","PaginationToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminListDevices',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "Limit": "",\n  "PaginationToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: '', Limit: '', PaginationToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', Limit: '', PaginationToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  Limit: '',
  PaginationToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminListDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', Limit: '', PaginationToken: ''}
};

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=AWSCognitoIdentityProviderService.AdminListDevices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","Limit":"","PaginationToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"Limit": @"",
                              @"PaginationToken": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'Limit' => '',
    'PaginationToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminListDevices', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'Limit' => '',
  'PaginationToken' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'Limit' => '',
  'PaginationToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices"

payload = {
    "UserPoolId": "",
    "Username": "",
    "Limit": "",
    "PaginationToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "Limit": "",
        "PaginationToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "Limit": "",\n  "PaginationToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListDevices'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "Limit": "",
  "PaginationToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminListGroupsForUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser

HEADERS

X-Amz-Target

BODY json

{
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:Username ""
                                                                                                                                 :UserPoolId ""
                                                                                                                                 :Limit ""
                                                                                                                                 :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser"

	payload := strings.NewReader("{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Username: '',
  UserPoolId: '',
  Limit: '',
  NextToken: ''
});

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=AWSCognitoIdentityProviderService.AdminListGroupsForUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Username: '', UserPoolId: '', Limit: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Username":"","UserPoolId":"","Limit":"","NextToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminListGroupsForUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Username": "",\n  "UserPoolId": "",\n  "Limit": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({Username: '', UserPoolId: '', Limit: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Username: '', UserPoolId: '', Limit: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  Username: '',
  UserPoolId: '',
  Limit: '',
  NextToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminListGroupsForUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Username: '', UserPoolId: '', Limit: '', NextToken: ''}
};

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=AWSCognitoIdentityProviderService.AdminListGroupsForUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Username":"","UserPoolId":"","Limit":"","NextToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Username": @"",
                              @"UserPoolId": @"",
                              @"Limit": @"",
                              @"NextToken": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Username' => '',
    'UserPoolId' => '',
    'Limit' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminListGroupsForUser', [
  'body' => '{
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Username' => '',
  'UserPoolId' => '',
  'Limit' => '',
  'NextToken' => ''
]));

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

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

append(json_encode([
  'Username' => '',
  'UserPoolId' => '',
  'Limit' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser"

payload = {
    "Username": "",
    "UserPoolId": "",
    "Limit": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser"

payload <- "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Username\": \"\",\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Username": "",
        "UserPoolId": "",
        "Limit": "",
        "NextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}'

echo '{
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Username": "",\n  "UserPoolId": "",\n  "Limit": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListGroupsForUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Username": "",
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminListUserAuthEvents

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:UserPoolId ""
                                                                                                                                  :Username ""
                                                                                                                                  :MaxResults ""
                                                                                                                                  :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  MaxResults: '',
  NextToken: ''
});

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=AWSCognitoIdentityProviderService.AdminListUserAuthEvents');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', MaxResults: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminListUserAuthEvents',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({UserPoolId: '', Username: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', MaxResults: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminListUserAuthEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', MaxResults: '', NextToken: ''}
};

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=AWSCognitoIdentityProviderService.AdminListUserAuthEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","MaxResults":"","NextToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminListUserAuthEvents', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

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

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

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents"

payload = {
    "UserPoolId": "",
    "Username": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "MaxResults": "",
        "NextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminListUserAuthEvents'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST AdminRemoveUserFromGroup

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:UserPoolId ""
                                                                                                                                   :Username ""
                                                                                                                                   :GroupName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  GroupName: ''
});

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=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', GroupName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","GroupName":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "GroupName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: '', GroupName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', GroupName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  GroupName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', GroupName: ''}
};

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=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","GroupName":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"GroupName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'GroupName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'GroupName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'GroupName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup"

payload = {
    "UserPoolId": "",
    "Username": "",
    "GroupName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"GroupName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "GroupName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "GroupName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "GroupName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminResetUserPassword

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:UserPoolId ""
                                                                                                                                 :Username ""
                                                                                                                                 :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.AdminResetUserPassword');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', ClientMetadata: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminResetUserPassword',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: '', ClientMetadata: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', ClientMetadata: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminResetUserPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', ClientMetadata: ''}
};

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=AWSCognitoIdentityProviderService.AdminResetUserPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminResetUserPassword', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword"

payload = {
    "UserPoolId": "",
    "Username": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminResetUserPassword")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminRespondToAuthChallenge

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:UserPoolId ""
                                                                                                                                      :ClientId ""
                                                                                                                                      :ChallengeName ""
                                                                                                                                      :ChallengeResponses ""
                                                                                                                                      :Session ""
                                                                                                                                      :AnalyticsMetadata ""
                                                                                                                                      :ContextData ""
                                                                                                                                      :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 180

{
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  ChallengeName: '',
  ChallengeResponses: '',
  Session: '',
  AnalyticsMetadata: '',
  ContextData: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    ChallengeName: '',
    ChallengeResponses: '',
    Session: '',
    AnalyticsMetadata: '',
    ContextData: '',
    ClientMetadata: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","ChallengeName":"","ChallengeResponses":"","Session":"","AnalyticsMetadata":"","ContextData":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "ChallengeName": "",\n  "ChallengeResponses": "",\n  "Session": "",\n  "AnalyticsMetadata": "",\n  "ContextData": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  ChallengeName: '',
  ChallengeResponses: '',
  Session: '',
  AnalyticsMetadata: '',
  ContextData: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    ClientId: '',
    ChallengeName: '',
    ChallengeResponses: '',
    Session: '',
    AnalyticsMetadata: '',
    ContextData: '',
    ClientMetadata: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: '',
  ChallengeName: '',
  ChallengeResponses: '',
  Session: '',
  AnalyticsMetadata: '',
  ContextData: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    ChallengeName: '',
    ChallengeResponses: '',
    Session: '',
    AnalyticsMetadata: '',
    ContextData: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","ChallengeName":"","ChallengeResponses":"","Session":"","AnalyticsMetadata":"","ContextData":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"",
                              @"ChallengeName": @"",
                              @"ChallengeResponses": @"",
                              @"Session": @"",
                              @"AnalyticsMetadata": @"",
                              @"ContextData": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => '',
    'ChallengeName' => '',
    'ChallengeResponses' => '',
    'Session' => '',
    'AnalyticsMetadata' => '',
    'ContextData' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'ChallengeName' => '',
  'ChallengeResponses' => '',
  'Session' => '',
  'AnalyticsMetadata' => '',
  'ContextData' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'ChallengeName' => '',
  'ChallengeResponses' => '',
  'Session' => '',
  'AnalyticsMetadata' => '',
  'ContextData' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge"

payload = {
    "UserPoolId": "",
    "ClientId": "",
    "ChallengeName": "",
    "ChallengeResponses": "",
    "Session": "",
    "AnalyticsMetadata": "",
    "ContextData": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"Session\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": "",
        "ChallengeName": "",
        "ChallengeResponses": "",
        "Session": "",
        "AnalyticsMetadata": "",
        "ContextData": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "ChallengeName": "",\n  "ChallengeResponses": "",\n  "Session": "",\n  "AnalyticsMetadata": "",\n  "ContextData": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": "",
  "ChallengeName": "",
  "ChallengeResponses": "",
  "Session": "",
  "AnalyticsMetadata": "",
  "ContextData": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminSetUserMFAPreference

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference

HEADERS

X-Amz-Target

BODY json

{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:SMSMfaSettings ""
                                                                                                                                    :SoftwareTokenMfaSettings ""
                                                                                                                                    :Username ""
                                                                                                                                    :UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference"

	payload := strings.NewReader("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SMSMfaSettings: '',
  SoftwareTokenMfaSettings: '',
  Username: '',
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SMSMfaSettings: '', SoftwareTokenMfaSettings: '', Username: '', UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SMSMfaSettings":"","SoftwareTokenMfaSettings":"","Username":"","UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SMSMfaSettings": "",\n  "SoftwareTokenMfaSettings": "",\n  "Username": "",\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({SMSMfaSettings: '', SoftwareTokenMfaSettings: '', Username: '', UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {SMSMfaSettings: '', SoftwareTokenMfaSettings: '', Username: '', UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SMSMfaSettings: '',
  SoftwareTokenMfaSettings: '',
  Username: '',
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SMSMfaSettings: '', SoftwareTokenMfaSettings: '', Username: '', UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SMSMfaSettings":"","SoftwareTokenMfaSettings":"","Username":"","UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SMSMfaSettings": @"",
                              @"SoftwareTokenMfaSettings": @"",
                              @"Username": @"",
                              @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'SMSMfaSettings' => '',
    'SoftwareTokenMfaSettings' => '',
    'Username' => '',
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference', [
  'body' => '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SMSMfaSettings' => '',
  'SoftwareTokenMfaSettings' => '',
  'Username' => '',
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SMSMfaSettings' => '',
  'SoftwareTokenMfaSettings' => '',
  'Username' => '',
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference"

payload = {
    "SMSMfaSettings": "",
    "SoftwareTokenMfaSettings": "",
    "Username": "",
    "UserPoolId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference"

payload <- "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"Username\": \"\",\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference";

    let payload = json!({
        "SMSMfaSettings": "",
        "SoftwareTokenMfaSettings": "",
        "Username": "",
        "UserPoolId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
}'

echo '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SMSMfaSettings": "",\n  "SoftwareTokenMfaSettings": "",\n  "Username": "",\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "Username": "",
  "UserPoolId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserMFAPreference")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminSetUserPassword

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :Username ""
                                                                                                                               :Password ""
                                                                                                                               :Permanent ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  Password: '',
  Permanent: ''
});

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=AWSCognitoIdentityProviderService.AdminSetUserPassword');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', Password: '', Permanent: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","Password":"","Permanent":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminSetUserPassword',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "Password": "",\n  "Permanent": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: '', Password: '', Permanent: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', Password: '', Permanent: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  Password: '',
  Permanent: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminSetUserPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', Password: '', Permanent: ''}
};

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=AWSCognitoIdentityProviderService.AdminSetUserPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","Password":"","Permanent":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"Password": @"",
                              @"Permanent": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'Password' => '',
    'Permanent' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminSetUserPassword', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'Password' => '',
  'Permanent' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'Password' => '',
  'Permanent' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword"

payload = {
    "UserPoolId": "",
    "Username": "",
    "Password": "",
    "Permanent": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"Permanent\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "Password": "",
        "Permanent": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "Password": "",\n  "Permanent": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "Password": "",
  "Permanent": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserPassword")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminSetUserSettings

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :Username ""
                                                                                                                               :MFAOptions ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  MFAOptions: ''
});

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=AWSCognitoIdentityProviderService.AdminSetUserSettings');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', MFAOptions: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","MFAOptions":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminSetUserSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "MFAOptions": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: '', MFAOptions: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', MFAOptions: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  MFAOptions: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminSetUserSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', MFAOptions: ''}
};

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=AWSCognitoIdentityProviderService.AdminSetUserSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","MFAOptions":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"MFAOptions": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'MFAOptions' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminSetUserSettings', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'MFAOptions' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'MFAOptions' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings"

payload = {
    "UserPoolId": "",
    "Username": "",
    "MFAOptions": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"MFAOptions\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "MFAOptions": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "MFAOptions": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "MFAOptions": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminSetUserSettings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminUpdateAuthEventFeedback

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:UserPoolId ""
                                                                                                                                       :Username ""
                                                                                                                                       :EventId ""
                                                                                                                                       :FeedbackValue ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 80

{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  EventId: '',
  FeedbackValue: ''
});

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=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', EventId: '', FeedbackValue: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","EventId":"","FeedbackValue":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "EventId": "",\n  "FeedbackValue": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: '', EventId: '', FeedbackValue: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', EventId: '', FeedbackValue: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  EventId: '',
  FeedbackValue: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', EventId: '', FeedbackValue: ''}
};

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=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","EventId":"","FeedbackValue":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"EventId": @"",
                              @"FeedbackValue": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'EventId' => '',
    'FeedbackValue' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'EventId' => '',
  'FeedbackValue' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'EventId' => '',
  'FeedbackValue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback"

payload = {
    "UserPoolId": "",
    "Username": "",
    "EventId": "",
    "FeedbackValue": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackValue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "EventId": "",
        "FeedbackValue": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "EventId": "",\n  "FeedbackValue": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackValue": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminUpdateDeviceStatus

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:UserPoolId ""
                                                                                                                                  :Username ""
                                                                                                                                  :DeviceKey ""
                                                                                                                                  :DeviceRememberedStatus ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  DeviceKey: '',
  DeviceRememberedStatus: ''
});

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=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', DeviceKey: '', DeviceRememberedStatus: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","DeviceKey":"","DeviceRememberedStatus":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "DeviceKey": "",\n  "DeviceRememberedStatus": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: '', DeviceKey: '', DeviceRememberedStatus: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', DeviceKey: '', DeviceRememberedStatus: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  DeviceKey: '',
  DeviceRememberedStatus: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', DeviceKey: '', DeviceRememberedStatus: ''}
};

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=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","DeviceKey":"","DeviceRememberedStatus":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"DeviceKey": @"",
                              @"DeviceRememberedStatus": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'DeviceKey' => '',
    'DeviceRememberedStatus' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'DeviceKey' => '',
  'DeviceRememberedStatus' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'DeviceKey' => '',
  'DeviceRememberedStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus"

payload = {
    "UserPoolId": "",
    "Username": "",
    "DeviceKey": "",
    "DeviceRememberedStatus": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "DeviceKey": "",
        "DeviceRememberedStatus": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "DeviceKey": "",\n  "DeviceRememberedStatus": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminUpdateUserAttributes

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:UserPoolId ""
                                                                                                                                    :Username ""
                                                                                                                                    :UserAttributes ""
                                                                                                                                    :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 88

{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  UserAttributes: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', UserAttributes: '', ClientMetadata: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","UserAttributes":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "UserAttributes": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: '', UserAttributes: '', ClientMetadata: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: '', UserAttributes: '', ClientMetadata: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  UserAttributes: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: '', UserAttributes: '', ClientMetadata: ''}
};

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=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","UserAttributes":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"UserAttributes": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'UserAttributes' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'UserAttributes' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'UserAttributes' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes"

payload = {
    "UserPoolId": "",
    "Username": "",
    "UserAttributes": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"UserAttributes\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "UserAttributes": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "UserAttributes": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "UserAttributes": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUpdateUserAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AdminUserGlobalSignOut

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:UserPoolId ""
                                                                                                                                 :Username ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "Username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: ''
});

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=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Username: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Username: ''}
};

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=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut', [
  'body' => '{
  "UserPoolId": "",
  "Username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut"

payload = {
    "UserPoolId": "",
    "Username": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut";

    let payload = json!({
        "UserPoolId": "",
        "Username": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": ""
}'

echo '{
  "UserPoolId": "",
  "Username": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AdminUserGlobalSignOut")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST AssociateSoftwareToken

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "Session": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:AccessToken ""
                                                                                                                                 :Session ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "AccessToken": "",
  "Session": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  Session: ''
});

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=AWSCognitoIdentityProviderService.AssociateSoftwareToken');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', Session: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","Session":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.AssociateSoftwareToken',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "Session": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', Session: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', Session: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  Session: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.AssociateSoftwareToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', Session: ''}
};

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=AWSCognitoIdentityProviderService.AssociateSoftwareToken';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","Session":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"Session": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'Session' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.AssociateSoftwareToken', [
  'body' => '{
  "AccessToken": "",
  "Session": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'Session' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'Session' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "Session": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "Session": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken"

payload = {
    "AccessToken": "",
    "Session": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken"

payload <- "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken";

    let payload = json!({
        "AccessToken": "",
        "Session": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "Session": ""
}'

echo '{
  "AccessToken": "",
  "Session": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "Session": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "Session": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.AssociateSoftwareToken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ChangePassword

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword

HEADERS

X-Amz-Target

BODY json

{
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:PreviousPassword ""
                                                                                                                         :ProposedPassword ""
                                                                                                                         :AccessToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword"

	payload := strings.NewReader("{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PreviousPassword: '',
  ProposedPassword: '',
  AccessToken: ''
});

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=AWSCognitoIdentityProviderService.ChangePassword');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PreviousPassword: '', ProposedPassword: '', AccessToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PreviousPassword":"","ProposedPassword":"","AccessToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ChangePassword',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PreviousPassword": "",\n  "ProposedPassword": "",\n  "AccessToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({PreviousPassword: '', ProposedPassword: '', AccessToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {PreviousPassword: '', ProposedPassword: '', AccessToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PreviousPassword: '',
  ProposedPassword: '',
  AccessToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ChangePassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PreviousPassword: '', ProposedPassword: '', AccessToken: ''}
};

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=AWSCognitoIdentityProviderService.ChangePassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PreviousPassword":"","ProposedPassword":"","AccessToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"PreviousPassword": @"",
                              @"ProposedPassword": @"",
                              @"AccessToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'PreviousPassword' => '',
    'ProposedPassword' => '',
    'AccessToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ChangePassword', [
  'body' => '{
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PreviousPassword' => '',
  'ProposedPassword' => '',
  'AccessToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PreviousPassword' => '',
  'ProposedPassword' => '',
  'AccessToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword"

payload = {
    "PreviousPassword": "",
    "ProposedPassword": "",
    "AccessToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword"

payload <- "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"PreviousPassword\": \"\",\n  \"ProposedPassword\": \"\",\n  \"AccessToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword";

    let payload = json!({
        "PreviousPassword": "",
        "ProposedPassword": "",
        "AccessToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
}'

echo '{
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PreviousPassword": "",\n  "ProposedPassword": "",\n  "AccessToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "PreviousPassword": "",
  "ProposedPassword": "",
  "AccessToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ChangePassword")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ConfirmDevice

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:AccessToken ""
                                                                                                                        :DeviceKey ""
                                                                                                                        :DeviceSecretVerifierConfig ""
                                                                                                                        :DeviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  DeviceKey: '',
  DeviceSecretVerifierConfig: '',
  DeviceName: ''
});

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=AWSCognitoIdentityProviderService.ConfirmDevice');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', DeviceKey: '', DeviceSecretVerifierConfig: '', DeviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","DeviceKey":"","DeviceSecretVerifierConfig":"","DeviceName":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ConfirmDevice',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "DeviceKey": "",\n  "DeviceSecretVerifierConfig": "",\n  "DeviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', DeviceKey: '', DeviceSecretVerifierConfig: '', DeviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', DeviceKey: '', DeviceSecretVerifierConfig: '', DeviceName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  DeviceKey: '',
  DeviceSecretVerifierConfig: '',
  DeviceName: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ConfirmDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', DeviceKey: '', DeviceSecretVerifierConfig: '', DeviceName: ''}
};

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=AWSCognitoIdentityProviderService.ConfirmDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","DeviceKey":"","DeviceSecretVerifierConfig":"","DeviceName":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"DeviceKey": @"",
                              @"DeviceSecretVerifierConfig": @"",
                              @"DeviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'DeviceKey' => '',
    'DeviceSecretVerifierConfig' => '',
    'DeviceName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ConfirmDevice', [
  'body' => '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'DeviceKey' => '',
  'DeviceSecretVerifierConfig' => '',
  'DeviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'DeviceKey' => '',
  'DeviceSecretVerifierConfig' => '',
  'DeviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice"

payload = {
    "AccessToken": "",
    "DeviceKey": "",
    "DeviceSecretVerifierConfig": "",
    "DeviceName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice"

payload <- "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceSecretVerifierConfig\": \"\",\n  \"DeviceName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice";

    let payload = json!({
        "AccessToken": "",
        "DeviceKey": "",
        "DeviceSecretVerifierConfig": "",
        "DeviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
}'

echo '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "DeviceKey": "",\n  "DeviceSecretVerifierConfig": "",\n  "DeviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceSecretVerifierConfig": "",
  "DeviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmDevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ConfirmForgotPassword

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword

HEADERS

X-Amz-Target

BODY json

{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:ClientId ""
                                                                                                                                :SecretHash ""
                                                                                                                                :Username ""
                                                                                                                                :ConfirmationCode ""
                                                                                                                                :Password ""
                                                                                                                                :AnalyticsMetadata ""
                                                                                                                                :UserContextData ""
                                                                                                                                :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword"

	payload := strings.NewReader("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 178

{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientId: '',
  SecretHash: '',
  Username: '',
  ConfirmationCode: '',
  Password: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.ConfirmForgotPassword');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    ConfirmationCode: '',
    Password: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","Username":"","ConfirmationCode":"","Password":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ConfirmForgotPassword',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientId": "",\n  "SecretHash": "",\n  "Username": "",\n  "ConfirmationCode": "",\n  "Password": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ClientId: '',
  SecretHash: '',
  Username: '',
  ConfirmationCode: '',
  Password: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    ConfirmationCode: '',
    Password: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ClientId: '',
  SecretHash: '',
  Username: '',
  ConfirmationCode: '',
  Password: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ConfirmForgotPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    ConfirmationCode: '',
    Password: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.ConfirmForgotPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","Username":"","ConfirmationCode":"","Password":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientId": @"",
                              @"SecretHash": @"",
                              @"Username": @"",
                              @"ConfirmationCode": @"",
                              @"Password": @"",
                              @"AnalyticsMetadata": @"",
                              @"UserContextData": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ClientId' => '',
    'SecretHash' => '',
    'Username' => '',
    'ConfirmationCode' => '',
    'Password' => '',
    'AnalyticsMetadata' => '',
    'UserContextData' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ConfirmForgotPassword', [
  'body' => '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'Username' => '',
  'ConfirmationCode' => '',
  'Password' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'Username' => '',
  'ConfirmationCode' => '',
  'Password' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword"

payload = {
    "ClientId": "",
    "SecretHash": "",
    "Username": "",
    "ConfirmationCode": "",
    "Password": "",
    "AnalyticsMetadata": "",
    "UserContextData": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword"

payload <- "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"Password\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword";

    let payload = json!({
        "ClientId": "",
        "SecretHash": "",
        "Username": "",
        "ConfirmationCode": "",
        "Password": "",
        "AnalyticsMetadata": "",
        "UserContextData": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

echo '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientId": "",\n  "SecretHash": "",\n  "Username": "",\n  "ConfirmationCode": "",\n  "Password": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "Password": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmForgotPassword")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ConfirmSignUp

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp

HEADERS

X-Amz-Target

BODY json

{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:ClientId ""
                                                                                                                        :SecretHash ""
                                                                                                                        :Username ""
                                                                                                                        :ConfirmationCode ""
                                                                                                                        :ForceAliasCreation ""
                                                                                                                        :AnalyticsMetadata ""
                                                                                                                        :UserContextData ""
                                                                                                                        :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp"

	payload := strings.NewReader("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 188

{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientId: '',
  SecretHash: '',
  Username: '',
  ConfirmationCode: '',
  ForceAliasCreation: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.ConfirmSignUp');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    ConfirmationCode: '',
    ForceAliasCreation: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","Username":"","ConfirmationCode":"","ForceAliasCreation":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ConfirmSignUp',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientId": "",\n  "SecretHash": "",\n  "Username": "",\n  "ConfirmationCode": "",\n  "ForceAliasCreation": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ClientId: '',
  SecretHash: '',
  Username: '',
  ConfirmationCode: '',
  ForceAliasCreation: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    ConfirmationCode: '',
    ForceAliasCreation: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ClientId: '',
  SecretHash: '',
  Username: '',
  ConfirmationCode: '',
  ForceAliasCreation: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ConfirmSignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    ConfirmationCode: '',
    ForceAliasCreation: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.ConfirmSignUp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","Username":"","ConfirmationCode":"","ForceAliasCreation":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientId": @"",
                              @"SecretHash": @"",
                              @"Username": @"",
                              @"ConfirmationCode": @"",
                              @"ForceAliasCreation": @"",
                              @"AnalyticsMetadata": @"",
                              @"UserContextData": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ClientId' => '',
    'SecretHash' => '',
    'Username' => '',
    'ConfirmationCode' => '',
    'ForceAliasCreation' => '',
    'AnalyticsMetadata' => '',
    'UserContextData' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ConfirmSignUp', [
  'body' => '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'Username' => '',
  'ConfirmationCode' => '',
  'ForceAliasCreation' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'Username' => '',
  'ConfirmationCode' => '',
  'ForceAliasCreation' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp"

payload = {
    "ClientId": "",
    "SecretHash": "",
    "Username": "",
    "ConfirmationCode": "",
    "ForceAliasCreation": "",
    "AnalyticsMetadata": "",
    "UserContextData": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp"

payload <- "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"ConfirmationCode\": \"\",\n  \"ForceAliasCreation\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp";

    let payload = json!({
        "ClientId": "",
        "SecretHash": "",
        "Username": "",
        "ConfirmationCode": "",
        "ForceAliasCreation": "",
        "AnalyticsMetadata": "",
        "UserContextData": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

echo '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientId": "",\n  "SecretHash": "",\n  "Username": "",\n  "ConfirmationCode": "",\n  "ForceAliasCreation": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "ConfirmationCode": "",
  "ForceAliasCreation": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ConfirmSignUp")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateGroup

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup

HEADERS

X-Amz-Target

BODY json

{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:GroupName ""
                                                                                                                      :UserPoolId ""
                                                                                                                      :Description ""
                                                                                                                      :RoleArn ""
                                                                                                                      :Precedence ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup"

	payload := strings.NewReader("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 99

{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GroupName: '',
  UserPoolId: '',
  Description: '',
  RoleArn: '',
  Precedence: ''
});

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=AWSCognitoIdentityProviderService.CreateGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":"","Description":"","RoleArn":"","Precedence":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.CreateGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GroupName": "",\n  "UserPoolId": "",\n  "Description": "",\n  "RoleArn": "",\n  "Precedence": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GroupName: '',
  UserPoolId: '',
  Description: '',
  RoleArn: '',
  Precedence: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.CreateGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''}
};

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=AWSCognitoIdentityProviderService.CreateGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":"","Description":"","RoleArn":"","Precedence":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GroupName": @"",
                              @"UserPoolId": @"",
                              @"Description": @"",
                              @"RoleArn": @"",
                              @"Precedence": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'GroupName' => '',
    'UserPoolId' => '',
    'Description' => '',
    'RoleArn' => '',
    'Precedence' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.CreateGroup', [
  'body' => '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GroupName' => '',
  'UserPoolId' => '',
  'Description' => '',
  'RoleArn' => '',
  'Precedence' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GroupName' => '',
  'UserPoolId' => '',
  'Description' => '',
  'RoleArn' => '',
  'Precedence' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup"

payload = {
    "GroupName": "",
    "UserPoolId": "",
    "Description": "",
    "RoleArn": "",
    "Precedence": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup"

payload <- "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup";

    let payload = json!({
        "GroupName": "",
        "UserPoolId": "",
        "Description": "",
        "RoleArn": "",
        "Precedence": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}'

echo '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GroupName": "",\n  "UserPoolId": "",\n  "Description": "",\n  "RoleArn": "",\n  "Precedence": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateIdentityProvider

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:UserPoolId ""
                                                                                                                                 :ProviderName ""
                                                                                                                                 :ProviderType ""
                                                                                                                                 :ProviderDetails ""
                                                                                                                                 :AttributeMapping ""
                                                                                                                                 :IdpIdentifiers ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ProviderName: '',
  ProviderType: '',
  ProviderDetails: '',
  AttributeMapping: '',
  IdpIdentifiers: ''
});

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=AWSCognitoIdentityProviderService.CreateIdentityProvider');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ProviderName: '',
    ProviderType: '',
    ProviderDetails: '',
    AttributeMapping: '',
    IdpIdentifiers: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":"","ProviderType":"","ProviderDetails":"","AttributeMapping":"","IdpIdentifiers":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.CreateIdentityProvider',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ProviderName": "",\n  "ProviderType": "",\n  "ProviderDetails": "",\n  "AttributeMapping": "",\n  "IdpIdentifiers": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  ProviderName: '',
  ProviderType: '',
  ProviderDetails: '',
  AttributeMapping: '',
  IdpIdentifiers: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    ProviderName: '',
    ProviderType: '',
    ProviderDetails: '',
    AttributeMapping: '',
    IdpIdentifiers: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ProviderName: '',
  ProviderType: '',
  ProviderDetails: '',
  AttributeMapping: '',
  IdpIdentifiers: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.CreateIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ProviderName: '',
    ProviderType: '',
    ProviderDetails: '',
    AttributeMapping: '',
    IdpIdentifiers: ''
  }
};

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=AWSCognitoIdentityProviderService.CreateIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":"","ProviderType":"","ProviderDetails":"","AttributeMapping":"","IdpIdentifiers":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ProviderName": @"",
                              @"ProviderType": @"",
                              @"ProviderDetails": @"",
                              @"AttributeMapping": @"",
                              @"IdpIdentifiers": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ProviderName' => '',
    'ProviderType' => '',
    'ProviderDetails' => '',
    'AttributeMapping' => '',
    'IdpIdentifiers' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.CreateIdentityProvider', [
  'body' => '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ProviderName' => '',
  'ProviderType' => '',
  'ProviderDetails' => '',
  'AttributeMapping' => '',
  'IdpIdentifiers' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ProviderName' => '',
  'ProviderType' => '',
  'ProviderDetails' => '',
  'AttributeMapping' => '',
  'IdpIdentifiers' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider"

payload = {
    "UserPoolId": "",
    "ProviderName": "",
    "ProviderType": "",
    "ProviderDetails": "",
    "AttributeMapping": "",
    "IdpIdentifiers": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderType\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider";

    let payload = json!({
        "UserPoolId": "",
        "ProviderName": "",
        "ProviderType": "",
        "ProviderDetails": "",
        "AttributeMapping": "",
        "IdpIdentifiers": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}'

echo '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ProviderName": "",\n  "ProviderType": "",\n  "ProviderDetails": "",\n  "AttributeMapping": "",\n  "IdpIdentifiers": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderType": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateIdentityProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateResourceServer

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :Identifier ""
                                                                                                                               :Name ""
                                                                                                                               :Scopes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Identifier: '',
  Name: '',
  Scopes: ''
});

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=AWSCognitoIdentityProviderService.CreateResourceServer');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: '', Name: '', Scopes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":"","Name":"","Scopes":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.CreateResourceServer',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Identifier": "",\n  "Name": "",\n  "Scopes": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Identifier: '', Name: '', Scopes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Identifier: '', Name: '', Scopes: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Identifier: '',
  Name: '',
  Scopes: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.CreateResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: '', Name: '', Scopes: ''}
};

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=AWSCognitoIdentityProviderService.CreateResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":"","Name":"","Scopes":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Identifier": @"",
                              @"Name": @"",
                              @"Scopes": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Identifier' => '',
    'Name' => '',
    'Scopes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.CreateResourceServer', [
  'body' => '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Identifier' => '',
  'Name' => '',
  'Scopes' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Identifier' => '',
  'Name' => '',
  'Scopes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer"

payload = {
    "UserPoolId": "",
    "Identifier": "",
    "Name": "",
    "Scopes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer";

    let payload = json!({
        "UserPoolId": "",
        "Identifier": "",
        "Name": "",
        "Scopes": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}'

echo '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Identifier": "",\n  "Name": "",\n  "Scopes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateResourceServer")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUserImportJob

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob

HEADERS

X-Amz-Target

BODY json

{
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:JobName ""
                                                                                                                              :UserPoolId ""
                                                                                                                              :CloudWatchLogsRoleArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob"

	payload := strings.NewReader("{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobName: '',
  UserPoolId: '',
  CloudWatchLogsRoleArn: ''
});

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=AWSCognitoIdentityProviderService.CreateUserImportJob');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobName: '', UserPoolId: '', CloudWatchLogsRoleArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobName":"","UserPoolId":"","CloudWatchLogsRoleArn":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.CreateUserImportJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobName": "",\n  "UserPoolId": "",\n  "CloudWatchLogsRoleArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({JobName: '', UserPoolId: '', CloudWatchLogsRoleArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {JobName: '', UserPoolId: '', CloudWatchLogsRoleArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  JobName: '',
  UserPoolId: '',
  CloudWatchLogsRoleArn: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.CreateUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobName: '', UserPoolId: '', CloudWatchLogsRoleArn: ''}
};

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=AWSCognitoIdentityProviderService.CreateUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobName":"","UserPoolId":"","CloudWatchLogsRoleArn":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"JobName": @"",
                              @"UserPoolId": @"",
                              @"CloudWatchLogsRoleArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'JobName' => '',
    'UserPoolId' => '',
    'CloudWatchLogsRoleArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.CreateUserImportJob', [
  'body' => '{
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'JobName' => '',
  'UserPoolId' => '',
  'CloudWatchLogsRoleArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'JobName' => '',
  'UserPoolId' => '',
  'CloudWatchLogsRoleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob"

payload = {
    "JobName": "",
    "UserPoolId": "",
    "CloudWatchLogsRoleArn": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob"

payload <- "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"JobName\": \"\",\n  \"UserPoolId\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob";

    let payload = json!({
        "JobName": "",
        "UserPoolId": "",
        "CloudWatchLogsRoleArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
}'

echo '{
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "JobName": "",\n  "UserPoolId": "",\n  "CloudWatchLogsRoleArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "JobName": "",
  "UserPoolId": "",
  "CloudWatchLogsRoleArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserImportJob")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUserPool

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool

HEADERS

X-Amz-Target

BODY json

{
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:PoolName ""
                                                                                                                         :Policies ""
                                                                                                                         :DeletionProtection ""
                                                                                                                         :LambdaConfig ""
                                                                                                                         :AutoVerifiedAttributes ""
                                                                                                                         :AliasAttributes ""
                                                                                                                         :UsernameAttributes ""
                                                                                                                         :SmsVerificationMessage ""
                                                                                                                         :EmailVerificationMessage ""
                                                                                                                         :EmailVerificationSubject ""
                                                                                                                         :VerificationMessageTemplate ""
                                                                                                                         :SmsAuthenticationMessage ""
                                                                                                                         :MfaConfiguration ""
                                                                                                                         :UserAttributeUpdateSettings ""
                                                                                                                         :DeviceConfiguration ""
                                                                                                                         :EmailConfiguration ""
                                                                                                                         :SmsConfiguration ""
                                                                                                                         :UserPoolTags ""
                                                                                                                         :AdminCreateUserConfig ""
                                                                                                                         :Schema ""
                                                                                                                         :UserPoolAddOns ""
                                                                                                                         :UsernameConfiguration ""
                                                                                                                         :AccountRecoverySetting ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool"

	payload := strings.NewReader("{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 646

{
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PoolName: '',
  Policies: '',
  DeletionProtection: '',
  LambdaConfig: '',
  AutoVerifiedAttributes: '',
  AliasAttributes: '',
  UsernameAttributes: '',
  SmsVerificationMessage: '',
  EmailVerificationMessage: '',
  EmailVerificationSubject: '',
  VerificationMessageTemplate: '',
  SmsAuthenticationMessage: '',
  MfaConfiguration: '',
  UserAttributeUpdateSettings: '',
  DeviceConfiguration: '',
  EmailConfiguration: '',
  SmsConfiguration: '',
  UserPoolTags: '',
  AdminCreateUserConfig: '',
  Schema: '',
  UserPoolAddOns: '',
  UsernameConfiguration: '',
  AccountRecoverySetting: ''
});

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=AWSCognitoIdentityProviderService.CreateUserPool');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    PoolName: '',
    Policies: '',
    DeletionProtection: '',
    LambdaConfig: '',
    AutoVerifiedAttributes: '',
    AliasAttributes: '',
    UsernameAttributes: '',
    SmsVerificationMessage: '',
    EmailVerificationMessage: '',
    EmailVerificationSubject: '',
    VerificationMessageTemplate: '',
    SmsAuthenticationMessage: '',
    MfaConfiguration: '',
    UserAttributeUpdateSettings: '',
    DeviceConfiguration: '',
    EmailConfiguration: '',
    SmsConfiguration: '',
    UserPoolTags: '',
    AdminCreateUserConfig: '',
    Schema: '',
    UserPoolAddOns: '',
    UsernameConfiguration: '',
    AccountRecoverySetting: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolName":"","Policies":"","DeletionProtection":"","LambdaConfig":"","AutoVerifiedAttributes":"","AliasAttributes":"","UsernameAttributes":"","SmsVerificationMessage":"","EmailVerificationMessage":"","EmailVerificationSubject":"","VerificationMessageTemplate":"","SmsAuthenticationMessage":"","MfaConfiguration":"","UserAttributeUpdateSettings":"","DeviceConfiguration":"","EmailConfiguration":"","SmsConfiguration":"","UserPoolTags":"","AdminCreateUserConfig":"","Schema":"","UserPoolAddOns":"","UsernameConfiguration":"","AccountRecoverySetting":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.CreateUserPool',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PoolName": "",\n  "Policies": "",\n  "DeletionProtection": "",\n  "LambdaConfig": "",\n  "AutoVerifiedAttributes": "",\n  "AliasAttributes": "",\n  "UsernameAttributes": "",\n  "SmsVerificationMessage": "",\n  "EmailVerificationMessage": "",\n  "EmailVerificationSubject": "",\n  "VerificationMessageTemplate": "",\n  "SmsAuthenticationMessage": "",\n  "MfaConfiguration": "",\n  "UserAttributeUpdateSettings": "",\n  "DeviceConfiguration": "",\n  "EmailConfiguration": "",\n  "SmsConfiguration": "",\n  "UserPoolTags": "",\n  "AdminCreateUserConfig": "",\n  "Schema": "",\n  "UserPoolAddOns": "",\n  "UsernameConfiguration": "",\n  "AccountRecoverySetting": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  PoolName: '',
  Policies: '',
  DeletionProtection: '',
  LambdaConfig: '',
  AutoVerifiedAttributes: '',
  AliasAttributes: '',
  UsernameAttributes: '',
  SmsVerificationMessage: '',
  EmailVerificationMessage: '',
  EmailVerificationSubject: '',
  VerificationMessageTemplate: '',
  SmsAuthenticationMessage: '',
  MfaConfiguration: '',
  UserAttributeUpdateSettings: '',
  DeviceConfiguration: '',
  EmailConfiguration: '',
  SmsConfiguration: '',
  UserPoolTags: '',
  AdminCreateUserConfig: '',
  Schema: '',
  UserPoolAddOns: '',
  UsernameConfiguration: '',
  AccountRecoverySetting: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    PoolName: '',
    Policies: '',
    DeletionProtection: '',
    LambdaConfig: '',
    AutoVerifiedAttributes: '',
    AliasAttributes: '',
    UsernameAttributes: '',
    SmsVerificationMessage: '',
    EmailVerificationMessage: '',
    EmailVerificationSubject: '',
    VerificationMessageTemplate: '',
    SmsAuthenticationMessage: '',
    MfaConfiguration: '',
    UserAttributeUpdateSettings: '',
    DeviceConfiguration: '',
    EmailConfiguration: '',
    SmsConfiguration: '',
    UserPoolTags: '',
    AdminCreateUserConfig: '',
    Schema: '',
    UserPoolAddOns: '',
    UsernameConfiguration: '',
    AccountRecoverySetting: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PoolName: '',
  Policies: '',
  DeletionProtection: '',
  LambdaConfig: '',
  AutoVerifiedAttributes: '',
  AliasAttributes: '',
  UsernameAttributes: '',
  SmsVerificationMessage: '',
  EmailVerificationMessage: '',
  EmailVerificationSubject: '',
  VerificationMessageTemplate: '',
  SmsAuthenticationMessage: '',
  MfaConfiguration: '',
  UserAttributeUpdateSettings: '',
  DeviceConfiguration: '',
  EmailConfiguration: '',
  SmsConfiguration: '',
  UserPoolTags: '',
  AdminCreateUserConfig: '',
  Schema: '',
  UserPoolAddOns: '',
  UsernameConfiguration: '',
  AccountRecoverySetting: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.CreateUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    PoolName: '',
    Policies: '',
    DeletionProtection: '',
    LambdaConfig: '',
    AutoVerifiedAttributes: '',
    AliasAttributes: '',
    UsernameAttributes: '',
    SmsVerificationMessage: '',
    EmailVerificationMessage: '',
    EmailVerificationSubject: '',
    VerificationMessageTemplate: '',
    SmsAuthenticationMessage: '',
    MfaConfiguration: '',
    UserAttributeUpdateSettings: '',
    DeviceConfiguration: '',
    EmailConfiguration: '',
    SmsConfiguration: '',
    UserPoolTags: '',
    AdminCreateUserConfig: '',
    Schema: '',
    UserPoolAddOns: '',
    UsernameConfiguration: '',
    AccountRecoverySetting: ''
  }
};

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=AWSCognitoIdentityProviderService.CreateUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolName":"","Policies":"","DeletionProtection":"","LambdaConfig":"","AutoVerifiedAttributes":"","AliasAttributes":"","UsernameAttributes":"","SmsVerificationMessage":"","EmailVerificationMessage":"","EmailVerificationSubject":"","VerificationMessageTemplate":"","SmsAuthenticationMessage":"","MfaConfiguration":"","UserAttributeUpdateSettings":"","DeviceConfiguration":"","EmailConfiguration":"","SmsConfiguration":"","UserPoolTags":"","AdminCreateUserConfig":"","Schema":"","UserPoolAddOns":"","UsernameConfiguration":"","AccountRecoverySetting":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"PoolName": @"",
                              @"Policies": @"",
                              @"DeletionProtection": @"",
                              @"LambdaConfig": @"",
                              @"AutoVerifiedAttributes": @"",
                              @"AliasAttributes": @"",
                              @"UsernameAttributes": @"",
                              @"SmsVerificationMessage": @"",
                              @"EmailVerificationMessage": @"",
                              @"EmailVerificationSubject": @"",
                              @"VerificationMessageTemplate": @"",
                              @"SmsAuthenticationMessage": @"",
                              @"MfaConfiguration": @"",
                              @"UserAttributeUpdateSettings": @"",
                              @"DeviceConfiguration": @"",
                              @"EmailConfiguration": @"",
                              @"SmsConfiguration": @"",
                              @"UserPoolTags": @"",
                              @"AdminCreateUserConfig": @"",
                              @"Schema": @"",
                              @"UserPoolAddOns": @"",
                              @"UsernameConfiguration": @"",
                              @"AccountRecoverySetting": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'PoolName' => '',
    'Policies' => '',
    'DeletionProtection' => '',
    'LambdaConfig' => '',
    'AutoVerifiedAttributes' => '',
    'AliasAttributes' => '',
    'UsernameAttributes' => '',
    'SmsVerificationMessage' => '',
    'EmailVerificationMessage' => '',
    'EmailVerificationSubject' => '',
    'VerificationMessageTemplate' => '',
    'SmsAuthenticationMessage' => '',
    'MfaConfiguration' => '',
    'UserAttributeUpdateSettings' => '',
    'DeviceConfiguration' => '',
    'EmailConfiguration' => '',
    'SmsConfiguration' => '',
    'UserPoolTags' => '',
    'AdminCreateUserConfig' => '',
    'Schema' => '',
    'UserPoolAddOns' => '',
    'UsernameConfiguration' => '',
    'AccountRecoverySetting' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.CreateUserPool', [
  'body' => '{
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PoolName' => '',
  'Policies' => '',
  'DeletionProtection' => '',
  'LambdaConfig' => '',
  'AutoVerifiedAttributes' => '',
  'AliasAttributes' => '',
  'UsernameAttributes' => '',
  'SmsVerificationMessage' => '',
  'EmailVerificationMessage' => '',
  'EmailVerificationSubject' => '',
  'VerificationMessageTemplate' => '',
  'SmsAuthenticationMessage' => '',
  'MfaConfiguration' => '',
  'UserAttributeUpdateSettings' => '',
  'DeviceConfiguration' => '',
  'EmailConfiguration' => '',
  'SmsConfiguration' => '',
  'UserPoolTags' => '',
  'AdminCreateUserConfig' => '',
  'Schema' => '',
  'UserPoolAddOns' => '',
  'UsernameConfiguration' => '',
  'AccountRecoverySetting' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PoolName' => '',
  'Policies' => '',
  'DeletionProtection' => '',
  'LambdaConfig' => '',
  'AutoVerifiedAttributes' => '',
  'AliasAttributes' => '',
  'UsernameAttributes' => '',
  'SmsVerificationMessage' => '',
  'EmailVerificationMessage' => '',
  'EmailVerificationSubject' => '',
  'VerificationMessageTemplate' => '',
  'SmsAuthenticationMessage' => '',
  'MfaConfiguration' => '',
  'UserAttributeUpdateSettings' => '',
  'DeviceConfiguration' => '',
  'EmailConfiguration' => '',
  'SmsConfiguration' => '',
  'UserPoolTags' => '',
  'AdminCreateUserConfig' => '',
  'Schema' => '',
  'UserPoolAddOns' => '',
  'UsernameConfiguration' => '',
  'AccountRecoverySetting' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool"

payload = {
    "PoolName": "",
    "Policies": "",
    "DeletionProtection": "",
    "LambdaConfig": "",
    "AutoVerifiedAttributes": "",
    "AliasAttributes": "",
    "UsernameAttributes": "",
    "SmsVerificationMessage": "",
    "EmailVerificationMessage": "",
    "EmailVerificationSubject": "",
    "VerificationMessageTemplate": "",
    "SmsAuthenticationMessage": "",
    "MfaConfiguration": "",
    "UserAttributeUpdateSettings": "",
    "DeviceConfiguration": "",
    "EmailConfiguration": "",
    "SmsConfiguration": "",
    "UserPoolTags": "",
    "AdminCreateUserConfig": "",
    "Schema": "",
    "UserPoolAddOns": "",
    "UsernameConfiguration": "",
    "AccountRecoverySetting": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool"

payload <- "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"PoolName\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"AliasAttributes\": \"\",\n  \"UsernameAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"Schema\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"UsernameConfiguration\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool";

    let payload = json!({
        "PoolName": "",
        "Policies": "",
        "DeletionProtection": "",
        "LambdaConfig": "",
        "AutoVerifiedAttributes": "",
        "AliasAttributes": "",
        "UsernameAttributes": "",
        "SmsVerificationMessage": "",
        "EmailVerificationMessage": "",
        "EmailVerificationSubject": "",
        "VerificationMessageTemplate": "",
        "SmsAuthenticationMessage": "",
        "MfaConfiguration": "",
        "UserAttributeUpdateSettings": "",
        "DeviceConfiguration": "",
        "EmailConfiguration": "",
        "SmsConfiguration": "",
        "UserPoolTags": "",
        "AdminCreateUserConfig": "",
        "Schema": "",
        "UserPoolAddOns": "",
        "UsernameConfiguration": "",
        "AccountRecoverySetting": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
}'

echo '{
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PoolName": "",\n  "Policies": "",\n  "DeletionProtection": "",\n  "LambdaConfig": "",\n  "AutoVerifiedAttributes": "",\n  "AliasAttributes": "",\n  "UsernameAttributes": "",\n  "SmsVerificationMessage": "",\n  "EmailVerificationMessage": "",\n  "EmailVerificationSubject": "",\n  "VerificationMessageTemplate": "",\n  "SmsAuthenticationMessage": "",\n  "MfaConfiguration": "",\n  "UserAttributeUpdateSettings": "",\n  "DeviceConfiguration": "",\n  "EmailConfiguration": "",\n  "SmsConfiguration": "",\n  "UserPoolTags": "",\n  "AdminCreateUserConfig": "",\n  "Schema": "",\n  "UserPoolAddOns": "",\n  "UsernameConfiguration": "",\n  "AccountRecoverySetting": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "PoolName": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "AliasAttributes": "",
  "UsernameAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "MfaConfiguration": "",
  "UserAttributeUpdateSettings": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "Schema": "",
  "UserPoolAddOns": "",
  "UsernameConfiguration": "",
  "AccountRecoverySetting": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPool")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUserPoolClient

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :ClientName ""
                                                                                                                               :GenerateSecret ""
                                                                                                                               :RefreshTokenValidity ""
                                                                                                                               :AccessTokenValidity ""
                                                                                                                               :IdTokenValidity ""
                                                                                                                               :TokenValidityUnits ""
                                                                                                                               :ReadAttributes ""
                                                                                                                               :WriteAttributes ""
                                                                                                                               :ExplicitAuthFlows ""
                                                                                                                               :SupportedIdentityProviders ""
                                                                                                                               :CallbackURLs ""
                                                                                                                               :LogoutURLs ""
                                                                                                                               :DefaultRedirectURI ""
                                                                                                                               :AllowedOAuthFlows ""
                                                                                                                               :AllowedOAuthScopes ""
                                                                                                                               :AllowedOAuthFlowsUserPoolClient ""
                                                                                                                               :AnalyticsConfiguration ""
                                                                                                                               :PreventUserExistenceErrors ""
                                                                                                                               :EnableTokenRevocation ""
                                                                                                                               :EnablePropagateAdditionalUserContextData ""
                                                                                                                               :AuthSessionValidity ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 634

{
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientName: '',
  GenerateSecret: '',
  RefreshTokenValidity: '',
  AccessTokenValidity: '',
  IdTokenValidity: '',
  TokenValidityUnits: '',
  ReadAttributes: '',
  WriteAttributes: '',
  ExplicitAuthFlows: '',
  SupportedIdentityProviders: '',
  CallbackURLs: '',
  LogoutURLs: '',
  DefaultRedirectURI: '',
  AllowedOAuthFlows: '',
  AllowedOAuthScopes: '',
  AllowedOAuthFlowsUserPoolClient: '',
  AnalyticsConfiguration: '',
  PreventUserExistenceErrors: '',
  EnableTokenRevocation: '',
  EnablePropagateAdditionalUserContextData: '',
  AuthSessionValidity: ''
});

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=AWSCognitoIdentityProviderService.CreateUserPoolClient');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientName: '',
    GenerateSecret: '',
    RefreshTokenValidity: '',
    AccessTokenValidity: '',
    IdTokenValidity: '',
    TokenValidityUnits: '',
    ReadAttributes: '',
    WriteAttributes: '',
    ExplicitAuthFlows: '',
    SupportedIdentityProviders: '',
    CallbackURLs: '',
    LogoutURLs: '',
    DefaultRedirectURI: '',
    AllowedOAuthFlows: '',
    AllowedOAuthScopes: '',
    AllowedOAuthFlowsUserPoolClient: '',
    AnalyticsConfiguration: '',
    PreventUserExistenceErrors: '',
    EnableTokenRevocation: '',
    EnablePropagateAdditionalUserContextData: '',
    AuthSessionValidity: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientName":"","GenerateSecret":"","RefreshTokenValidity":"","AccessTokenValidity":"","IdTokenValidity":"","TokenValidityUnits":"","ReadAttributes":"","WriteAttributes":"","ExplicitAuthFlows":"","SupportedIdentityProviders":"","CallbackURLs":"","LogoutURLs":"","DefaultRedirectURI":"","AllowedOAuthFlows":"","AllowedOAuthScopes":"","AllowedOAuthFlowsUserPoolClient":"","AnalyticsConfiguration":"","PreventUserExistenceErrors":"","EnableTokenRevocation":"","EnablePropagateAdditionalUserContextData":"","AuthSessionValidity":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.CreateUserPoolClient',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientName": "",\n  "GenerateSecret": "",\n  "RefreshTokenValidity": "",\n  "AccessTokenValidity": "",\n  "IdTokenValidity": "",\n  "TokenValidityUnits": "",\n  "ReadAttributes": "",\n  "WriteAttributes": "",\n  "ExplicitAuthFlows": "",\n  "SupportedIdentityProviders": "",\n  "CallbackURLs": "",\n  "LogoutURLs": "",\n  "DefaultRedirectURI": "",\n  "AllowedOAuthFlows": "",\n  "AllowedOAuthScopes": "",\n  "AllowedOAuthFlowsUserPoolClient": "",\n  "AnalyticsConfiguration": "",\n  "PreventUserExistenceErrors": "",\n  "EnableTokenRevocation": "",\n  "EnablePropagateAdditionalUserContextData": "",\n  "AuthSessionValidity": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  ClientName: '',
  GenerateSecret: '',
  RefreshTokenValidity: '',
  AccessTokenValidity: '',
  IdTokenValidity: '',
  TokenValidityUnits: '',
  ReadAttributes: '',
  WriteAttributes: '',
  ExplicitAuthFlows: '',
  SupportedIdentityProviders: '',
  CallbackURLs: '',
  LogoutURLs: '',
  DefaultRedirectURI: '',
  AllowedOAuthFlows: '',
  AllowedOAuthScopes: '',
  AllowedOAuthFlowsUserPoolClient: '',
  AnalyticsConfiguration: '',
  PreventUserExistenceErrors: '',
  EnableTokenRevocation: '',
  EnablePropagateAdditionalUserContextData: '',
  AuthSessionValidity: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    ClientName: '',
    GenerateSecret: '',
    RefreshTokenValidity: '',
    AccessTokenValidity: '',
    IdTokenValidity: '',
    TokenValidityUnits: '',
    ReadAttributes: '',
    WriteAttributes: '',
    ExplicitAuthFlows: '',
    SupportedIdentityProviders: '',
    CallbackURLs: '',
    LogoutURLs: '',
    DefaultRedirectURI: '',
    AllowedOAuthFlows: '',
    AllowedOAuthScopes: '',
    AllowedOAuthFlowsUserPoolClient: '',
    AnalyticsConfiguration: '',
    PreventUserExistenceErrors: '',
    EnableTokenRevocation: '',
    EnablePropagateAdditionalUserContextData: '',
    AuthSessionValidity: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientName: '',
  GenerateSecret: '',
  RefreshTokenValidity: '',
  AccessTokenValidity: '',
  IdTokenValidity: '',
  TokenValidityUnits: '',
  ReadAttributes: '',
  WriteAttributes: '',
  ExplicitAuthFlows: '',
  SupportedIdentityProviders: '',
  CallbackURLs: '',
  LogoutURLs: '',
  DefaultRedirectURI: '',
  AllowedOAuthFlows: '',
  AllowedOAuthScopes: '',
  AllowedOAuthFlowsUserPoolClient: '',
  AnalyticsConfiguration: '',
  PreventUserExistenceErrors: '',
  EnableTokenRevocation: '',
  EnablePropagateAdditionalUserContextData: '',
  AuthSessionValidity: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.CreateUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientName: '',
    GenerateSecret: '',
    RefreshTokenValidity: '',
    AccessTokenValidity: '',
    IdTokenValidity: '',
    TokenValidityUnits: '',
    ReadAttributes: '',
    WriteAttributes: '',
    ExplicitAuthFlows: '',
    SupportedIdentityProviders: '',
    CallbackURLs: '',
    LogoutURLs: '',
    DefaultRedirectURI: '',
    AllowedOAuthFlows: '',
    AllowedOAuthScopes: '',
    AllowedOAuthFlowsUserPoolClient: '',
    AnalyticsConfiguration: '',
    PreventUserExistenceErrors: '',
    EnableTokenRevocation: '',
    EnablePropagateAdditionalUserContextData: '',
    AuthSessionValidity: ''
  }
};

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=AWSCognitoIdentityProviderService.CreateUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientName":"","GenerateSecret":"","RefreshTokenValidity":"","AccessTokenValidity":"","IdTokenValidity":"","TokenValidityUnits":"","ReadAttributes":"","WriteAttributes":"","ExplicitAuthFlows":"","SupportedIdentityProviders":"","CallbackURLs":"","LogoutURLs":"","DefaultRedirectURI":"","AllowedOAuthFlows":"","AllowedOAuthScopes":"","AllowedOAuthFlowsUserPoolClient":"","AnalyticsConfiguration":"","PreventUserExistenceErrors":"","EnableTokenRevocation":"","EnablePropagateAdditionalUserContextData":"","AuthSessionValidity":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientName": @"",
                              @"GenerateSecret": @"",
                              @"RefreshTokenValidity": @"",
                              @"AccessTokenValidity": @"",
                              @"IdTokenValidity": @"",
                              @"TokenValidityUnits": @"",
                              @"ReadAttributes": @"",
                              @"WriteAttributes": @"",
                              @"ExplicitAuthFlows": @"",
                              @"SupportedIdentityProviders": @"",
                              @"CallbackURLs": @"",
                              @"LogoutURLs": @"",
                              @"DefaultRedirectURI": @"",
                              @"AllowedOAuthFlows": @"",
                              @"AllowedOAuthScopes": @"",
                              @"AllowedOAuthFlowsUserPoolClient": @"",
                              @"AnalyticsConfiguration": @"",
                              @"PreventUserExistenceErrors": @"",
                              @"EnableTokenRevocation": @"",
                              @"EnablePropagateAdditionalUserContextData": @"",
                              @"AuthSessionValidity": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientName' => '',
    'GenerateSecret' => '',
    'RefreshTokenValidity' => '',
    'AccessTokenValidity' => '',
    'IdTokenValidity' => '',
    'TokenValidityUnits' => '',
    'ReadAttributes' => '',
    'WriteAttributes' => '',
    'ExplicitAuthFlows' => '',
    'SupportedIdentityProviders' => '',
    'CallbackURLs' => '',
    'LogoutURLs' => '',
    'DefaultRedirectURI' => '',
    'AllowedOAuthFlows' => '',
    'AllowedOAuthScopes' => '',
    'AllowedOAuthFlowsUserPoolClient' => '',
    'AnalyticsConfiguration' => '',
    'PreventUserExistenceErrors' => '',
    'EnableTokenRevocation' => '',
    'EnablePropagateAdditionalUserContextData' => '',
    'AuthSessionValidity' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.CreateUserPoolClient', [
  'body' => '{
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientName' => '',
  'GenerateSecret' => '',
  'RefreshTokenValidity' => '',
  'AccessTokenValidity' => '',
  'IdTokenValidity' => '',
  'TokenValidityUnits' => '',
  'ReadAttributes' => '',
  'WriteAttributes' => '',
  'ExplicitAuthFlows' => '',
  'SupportedIdentityProviders' => '',
  'CallbackURLs' => '',
  'LogoutURLs' => '',
  'DefaultRedirectURI' => '',
  'AllowedOAuthFlows' => '',
  'AllowedOAuthScopes' => '',
  'AllowedOAuthFlowsUserPoolClient' => '',
  'AnalyticsConfiguration' => '',
  'PreventUserExistenceErrors' => '',
  'EnableTokenRevocation' => '',
  'EnablePropagateAdditionalUserContextData' => '',
  'AuthSessionValidity' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientName' => '',
  'GenerateSecret' => '',
  'RefreshTokenValidity' => '',
  'AccessTokenValidity' => '',
  'IdTokenValidity' => '',
  'TokenValidityUnits' => '',
  'ReadAttributes' => '',
  'WriteAttributes' => '',
  'ExplicitAuthFlows' => '',
  'SupportedIdentityProviders' => '',
  'CallbackURLs' => '',
  'LogoutURLs' => '',
  'DefaultRedirectURI' => '',
  'AllowedOAuthFlows' => '',
  'AllowedOAuthScopes' => '',
  'AllowedOAuthFlowsUserPoolClient' => '',
  'AnalyticsConfiguration' => '',
  'PreventUserExistenceErrors' => '',
  'EnableTokenRevocation' => '',
  'EnablePropagateAdditionalUserContextData' => '',
  'AuthSessionValidity' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient"

payload = {
    "UserPoolId": "",
    "ClientName": "",
    "GenerateSecret": "",
    "RefreshTokenValidity": "",
    "AccessTokenValidity": "",
    "IdTokenValidity": "",
    "TokenValidityUnits": "",
    "ReadAttributes": "",
    "WriteAttributes": "",
    "ExplicitAuthFlows": "",
    "SupportedIdentityProviders": "",
    "CallbackURLs": "",
    "LogoutURLs": "",
    "DefaultRedirectURI": "",
    "AllowedOAuthFlows": "",
    "AllowedOAuthScopes": "",
    "AllowedOAuthFlowsUserPoolClient": "",
    "AnalyticsConfiguration": "",
    "PreventUserExistenceErrors": "",
    "EnableTokenRevocation": "",
    "EnablePropagateAdditionalUserContextData": "",
    "AuthSessionValidity": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientName\": \"\",\n  \"GenerateSecret\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient";

    let payload = json!({
        "UserPoolId": "",
        "ClientName": "",
        "GenerateSecret": "",
        "RefreshTokenValidity": "",
        "AccessTokenValidity": "",
        "IdTokenValidity": "",
        "TokenValidityUnits": "",
        "ReadAttributes": "",
        "WriteAttributes": "",
        "ExplicitAuthFlows": "",
        "SupportedIdentityProviders": "",
        "CallbackURLs": "",
        "LogoutURLs": "",
        "DefaultRedirectURI": "",
        "AllowedOAuthFlows": "",
        "AllowedOAuthScopes": "",
        "AllowedOAuthFlowsUserPoolClient": "",
        "AnalyticsConfiguration": "",
        "PreventUserExistenceErrors": "",
        "EnableTokenRevocation": "",
        "EnablePropagateAdditionalUserContextData": "",
        "AuthSessionValidity": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}'

echo '{
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientName": "",\n  "GenerateSecret": "",\n  "RefreshTokenValidity": "",\n  "AccessTokenValidity": "",\n  "IdTokenValidity": "",\n  "TokenValidityUnits": "",\n  "ReadAttributes": "",\n  "WriteAttributes": "",\n  "ExplicitAuthFlows": "",\n  "SupportedIdentityProviders": "",\n  "CallbackURLs": "",\n  "LogoutURLs": "",\n  "DefaultRedirectURI": "",\n  "AllowedOAuthFlows": "",\n  "AllowedOAuthScopes": "",\n  "AllowedOAuthFlowsUserPoolClient": "",\n  "AnalyticsConfiguration": "",\n  "PreventUserExistenceErrors": "",\n  "EnableTokenRevocation": "",\n  "EnablePropagateAdditionalUserContextData": "",\n  "AuthSessionValidity": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientName": "",
  "GenerateSecret": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolClient")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST CreateUserPoolDomain

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain

HEADERS

X-Amz-Target

BODY json

{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:Domain ""
                                                                                                                               :UserPoolId ""
                                                                                                                               :CustomDomainConfig ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain"

	payload := strings.NewReader("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Domain: '',
  UserPoolId: '',
  CustomDomainConfig: ''
});

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=AWSCognitoIdentityProviderService.CreateUserPoolDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: '', UserPoolId: '', CustomDomainConfig: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":"","UserPoolId":"","CustomDomainConfig":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.CreateUserPoolDomain',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Domain": "",\n  "UserPoolId": "",\n  "CustomDomainConfig": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Domain: '', UserPoolId: '', CustomDomainConfig: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Domain: '', UserPoolId: '', CustomDomainConfig: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Domain: '',
  UserPoolId: '',
  CustomDomainConfig: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.CreateUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: '', UserPoolId: '', CustomDomainConfig: ''}
};

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=AWSCognitoIdentityProviderService.CreateUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":"","UserPoolId":"","CustomDomainConfig":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Domain": @"",
                              @"UserPoolId": @"",
                              @"CustomDomainConfig": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Domain' => '',
    'UserPoolId' => '',
    'CustomDomainConfig' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.CreateUserPoolDomain', [
  'body' => '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Domain' => '',
  'UserPoolId' => '',
  'CustomDomainConfig' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Domain' => '',
  'UserPoolId' => '',
  'CustomDomainConfig' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain"

payload = {
    "Domain": "",
    "UserPoolId": "",
    "CustomDomainConfig": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain"

payload <- "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain";

    let payload = json!({
        "Domain": "",
        "UserPoolId": "",
        "CustomDomainConfig": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}'

echo '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Domain": "",\n  "UserPoolId": "",\n  "CustomDomainConfig": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.CreateUserPoolDomain")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteGroup

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup

HEADERS

X-Amz-Target

BODY json

{
  "GroupName": "",
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:GroupName ""
                                                                                                                      :UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup"

	payload := strings.NewReader("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "GroupName": "",
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GroupName: '',
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.DeleteGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GroupName": "",\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({GroupName: '', UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GroupName: '', UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GroupName: '',
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.DeleteGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GroupName": @"",
                              @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'GroupName' => '',
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteGroup', [
  'body' => '{
  "GroupName": "",
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GroupName' => '',
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GroupName' => '',
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup"

payload = {
    "GroupName": "",
    "UserPoolId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup"

payload <- "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup";

    let payload = json!({
        "GroupName": "",
        "UserPoolId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GroupName": "",
  "UserPoolId": ""
}'

echo '{
  "GroupName": "",
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GroupName": "",\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GroupName": "",
  "UserPoolId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteIdentityProvider

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ProviderName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:UserPoolId ""
                                                                                                                                 :ProviderName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "UserPoolId": "",
  "ProviderName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ProviderName: ''
});

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=AWSCognitoIdentityProviderService.DeleteIdentityProvider');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ProviderName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteIdentityProvider',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ProviderName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', ProviderName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', ProviderName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ProviderName: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ProviderName: ''}
};

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=AWSCognitoIdentityProviderService.DeleteIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ProviderName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ProviderName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteIdentityProvider', [
  'body' => '{
  "UserPoolId": "",
  "ProviderName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ProviderName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ProviderName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider"

payload = {
    "UserPoolId": "",
    "ProviderName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider";

    let payload = json!({
        "UserPoolId": "",
        "ProviderName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ProviderName": ""
}'

echo '{
  "UserPoolId": "",
  "ProviderName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ProviderName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ProviderName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteIdentityProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteResourceServer

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Identifier": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :Identifier ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "UserPoolId": "",
  "Identifier": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Identifier: ''
});

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=AWSCognitoIdentityProviderService.DeleteResourceServer');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteResourceServer',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Identifier": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Identifier: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Identifier: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Identifier: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: ''}
};

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=AWSCognitoIdentityProviderService.DeleteResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Identifier": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Identifier' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteResourceServer', [
  'body' => '{
  "UserPoolId": "",
  "Identifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Identifier' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Identifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer"

payload = {
    "UserPoolId": "",
    "Identifier": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer";

    let payload = json!({
        "UserPoolId": "",
        "Identifier": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Identifier": ""
}'

echo '{
  "UserPoolId": "",
  "Identifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Identifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Identifier": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteResourceServer")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AccessToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "AccessToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: ''
});

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=AWSCognitoIdentityProviderService.DeleteUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: ''}
};

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=AWSCognitoIdentityProviderService.DeleteUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteUser', [
  'body' => '{
  "AccessToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser"

payload = { "AccessToken": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser"

payload <- "{\n  \"AccessToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser";

    let payload = json!({"AccessToken": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": ""
}'

echo '{
  "AccessToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["AccessToken": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteUserAttributes

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes

HEADERS

X-Amz-Target

BODY json

{
  "UserAttributeNames": "",
  "AccessToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserAttributeNames ""
                                                                                                                               :AccessToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes"

	payload := strings.NewReader("{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "UserAttributeNames": "",
  "AccessToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserAttributeNames: '',
  AccessToken: ''
});

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=AWSCognitoIdentityProviderService.DeleteUserAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserAttributeNames: '', AccessToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserAttributeNames":"","AccessToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteUserAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserAttributeNames": "",\n  "AccessToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserAttributeNames: '', AccessToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserAttributeNames: '', AccessToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserAttributeNames: '',
  AccessToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserAttributeNames: '', AccessToken: ''}
};

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=AWSCognitoIdentityProviderService.DeleteUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserAttributeNames":"","AccessToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserAttributeNames": @"",
                              @"AccessToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserAttributeNames' => '',
    'AccessToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteUserAttributes', [
  'body' => '{
  "UserAttributeNames": "",
  "AccessToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserAttributeNames' => '',
  'AccessToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserAttributeNames' => '',
  'AccessToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserAttributeNames": "",
  "AccessToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserAttributeNames": "",
  "AccessToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes"

payload = {
    "UserAttributeNames": "",
    "AccessToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes"

payload <- "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserAttributeNames\": \"\",\n  \"AccessToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes";

    let payload = json!({
        "UserAttributeNames": "",
        "AccessToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserAttributeNames": "",
  "AccessToken": ""
}'

echo '{
  "UserAttributeNames": "",
  "AccessToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserAttributeNames": "",\n  "AccessToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserAttributeNames": "",
  "AccessToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteUserPool

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.DeleteUserPool');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteUserPool',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.DeleteUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteUserPool', [
  'body' => '{
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool"

payload = { "UserPoolId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool"

payload <- "{\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool";

    let payload = json!({"UserPoolId": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": ""
}'

echo '{
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["UserPoolId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPool")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteUserPoolClient

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :ClientId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "ClientId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: ''
});

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=AWSCognitoIdentityProviderService.DeleteUserPoolClient');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteUserPoolClient',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', ClientId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', ClientId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

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=AWSCognitoIdentityProviderService.DeleteUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteUserPoolClient', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient"

payload = {
    "UserPoolId": "",
    "ClientId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolClient")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteUserPoolDomain

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain

HEADERS

X-Amz-Target

BODY json

{
  "Domain": "",
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:Domain ""
                                                                                                                               :UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain"

	payload := strings.NewReader("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "Domain": "",
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Domain: '',
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.DeleteUserPoolDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: '', UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":"","UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DeleteUserPoolDomain',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Domain": "",\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Domain: '', UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Domain: '', UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Domain: '',
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DeleteUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: '', UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.DeleteUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":"","UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Domain": @"",
                              @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Domain' => '',
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DeleteUserPoolDomain', [
  'body' => '{
  "Domain": "",
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Domain' => '',
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Domain' => '',
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": "",
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": "",
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain"

payload = {
    "Domain": "",
    "UserPoolId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain"

payload <- "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain";

    let payload = json!({
        "Domain": "",
        "UserPoolId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Domain": "",
  "UserPoolId": ""
}'

echo '{
  "Domain": "",
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Domain": "",\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Domain": "",
  "UserPoolId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DeleteUserPoolDomain")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeIdentityProvider

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ProviderName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:UserPoolId ""
                                                                                                                                   :ProviderName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "UserPoolId": "",
  "ProviderName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ProviderName: ''
});

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=AWSCognitoIdentityProviderService.DescribeIdentityProvider');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ProviderName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DescribeIdentityProvider',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ProviderName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', ProviderName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', ProviderName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ProviderName: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DescribeIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ProviderName: ''}
};

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=AWSCognitoIdentityProviderService.DescribeIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ProviderName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ProviderName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DescribeIdentityProvider', [
  'body' => '{
  "UserPoolId": "",
  "ProviderName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ProviderName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ProviderName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider"

payload = {
    "UserPoolId": "",
    "ProviderName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider";

    let payload = json!({
        "UserPoolId": "",
        "ProviderName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ProviderName": ""
}'

echo '{
  "UserPoolId": "",
  "ProviderName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ProviderName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ProviderName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeIdentityProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeResourceServer

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Identifier": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:UserPoolId ""
                                                                                                                                 :Identifier ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "UserPoolId": "",
  "Identifier": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Identifier: ''
});

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=AWSCognitoIdentityProviderService.DescribeResourceServer');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DescribeResourceServer',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Identifier": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Identifier: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Identifier: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Identifier: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DescribeResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: ''}
};

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=AWSCognitoIdentityProviderService.DescribeResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Identifier": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Identifier' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DescribeResourceServer', [
  'body' => '{
  "UserPoolId": "",
  "Identifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Identifier' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Identifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer"

payload = {
    "UserPoolId": "",
    "Identifier": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer";

    let payload = json!({
        "UserPoolId": "",
        "Identifier": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Identifier": ""
}'

echo '{
  "UserPoolId": "",
  "Identifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Identifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Identifier": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeResourceServer")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeRiskConfiguration

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:UserPoolId ""
                                                                                                                                    :ClientId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "ClientId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: ''
});

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=AWSCognitoIdentityProviderService.DescribeRiskConfiguration');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DescribeRiskConfiguration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', ClientId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', ClientId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DescribeRiskConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

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=AWSCognitoIdentityProviderService.DescribeRiskConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DescribeRiskConfiguration', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration"

payload = {
    "UserPoolId": "",
    "ClientId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeRiskConfiguration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeUserImportJob

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "JobId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:UserPoolId ""
                                                                                                                                :JobId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "UserPoolId": "",
  "JobId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  JobId: ''
});

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=AWSCognitoIdentityProviderService.DescribeUserImportJob');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', JobId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","JobId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DescribeUserImportJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "JobId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', JobId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', JobId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  JobId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DescribeUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', JobId: ''}
};

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=AWSCognitoIdentityProviderService.DescribeUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","JobId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"JobId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'JobId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DescribeUserImportJob', [
  'body' => '{
  "UserPoolId": "",
  "JobId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'JobId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'JobId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "JobId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "JobId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob"

payload = {
    "UserPoolId": "",
    "JobId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob";

    let payload = json!({
        "UserPoolId": "",
        "JobId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "JobId": ""
}'

echo '{
  "UserPoolId": "",
  "JobId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "JobId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "JobId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserImportJob")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeUserPool

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.DescribeUserPool');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DescribeUserPool',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DescribeUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.DescribeUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DescribeUserPool', [
  'body' => '{
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool"

payload = { "UserPoolId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool"

payload <- "{\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool";

    let payload = json!({"UserPoolId": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": ""
}'

echo '{
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["UserPoolId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPool")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeUserPoolClient

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:UserPoolId ""
                                                                                                                                 :ClientId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "ClientId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: ''
});

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=AWSCognitoIdentityProviderService.DescribeUserPoolClient');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DescribeUserPoolClient',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', ClientId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', ClientId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DescribeUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

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=AWSCognitoIdentityProviderService.DescribeUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DescribeUserPoolClient', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient"

payload = {
    "UserPoolId": "",
    "ClientId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolClient")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DescribeUserPoolDomain

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain

HEADERS

X-Amz-Target

BODY json

{
  "Domain": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Domain\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:Domain ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Domain\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Domain\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Domain\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain"

	payload := strings.NewReader("{\n  \"Domain\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "Domain": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Domain\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Domain\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Domain\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Domain: ''
});

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=AWSCognitoIdentityProviderService.DescribeUserPoolDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.DescribeUserPoolDomain',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Domain": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Domain: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Domain: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Domain: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.DescribeUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: ''}
};

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=AWSCognitoIdentityProviderService.DescribeUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Domain": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Domain\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Domain' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.DescribeUserPoolDomain', [
  'body' => '{
  "Domain": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Domain' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Domain' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Domain\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain"

payload = { "Domain": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain"

payload <- "{\n  \"Domain\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Domain\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Domain\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain";

    let payload = json!({"Domain": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Domain": ""
}'

echo '{
  "Domain": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Domain": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Domain": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.DescribeUserPoolDomain")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ForgetDevice

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "DeviceKey": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:AccessToken ""
                                                                                                                       :DeviceKey ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "AccessToken": "",
  "DeviceKey": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  DeviceKey: ''
});

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=AWSCognitoIdentityProviderService.ForgetDevice');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', DeviceKey: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","DeviceKey":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ForgetDevice',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "DeviceKey": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', DeviceKey: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', DeviceKey: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  DeviceKey: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ForgetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', DeviceKey: ''}
};

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=AWSCognitoIdentityProviderService.ForgetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","DeviceKey":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"DeviceKey": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'DeviceKey' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ForgetDevice', [
  'body' => '{
  "AccessToken": "",
  "DeviceKey": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'DeviceKey' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'DeviceKey' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "DeviceKey": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "DeviceKey": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice"

payload = {
    "AccessToken": "",
    "DeviceKey": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice"

payload <- "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice";

    let payload = json!({
        "AccessToken": "",
        "DeviceKey": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "DeviceKey": ""
}'

echo '{
  "AccessToken": "",
  "DeviceKey": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "DeviceKey": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "DeviceKey": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgetDevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ForgotPassword

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword

HEADERS

X-Amz-Target

BODY json

{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:ClientId ""
                                                                                                                         :SecretHash ""
                                                                                                                         :UserContextData ""
                                                                                                                         :Username ""
                                                                                                                         :AnalyticsMetadata ""
                                                                                                                         :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword"

	payload := strings.NewReader("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 134

{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientId: '',
  SecretHash: '',
  UserContextData: '',
  Username: '',
  AnalyticsMetadata: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.ForgotPassword');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    UserContextData: '',
    Username: '',
    AnalyticsMetadata: '',
    ClientMetadata: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","UserContextData":"","Username":"","AnalyticsMetadata":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ForgotPassword',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientId": "",\n  "SecretHash": "",\n  "UserContextData": "",\n  "Username": "",\n  "AnalyticsMetadata": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ClientId: '',
  SecretHash: '',
  UserContextData: '',
  Username: '',
  AnalyticsMetadata: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientId: '',
    SecretHash: '',
    UserContextData: '',
    Username: '',
    AnalyticsMetadata: '',
    ClientMetadata: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ClientId: '',
  SecretHash: '',
  UserContextData: '',
  Username: '',
  AnalyticsMetadata: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ForgotPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    UserContextData: '',
    Username: '',
    AnalyticsMetadata: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.ForgotPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","UserContextData":"","Username":"","AnalyticsMetadata":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientId": @"",
                              @"SecretHash": @"",
                              @"UserContextData": @"",
                              @"Username": @"",
                              @"AnalyticsMetadata": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ClientId' => '',
    'SecretHash' => '',
    'UserContextData' => '',
    'Username' => '',
    'AnalyticsMetadata' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ForgotPassword', [
  'body' => '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'UserContextData' => '',
  'Username' => '',
  'AnalyticsMetadata' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'UserContextData' => '',
  'Username' => '',
  'AnalyticsMetadata' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword"

payload = {
    "ClientId": "",
    "SecretHash": "",
    "UserContextData": "",
    "Username": "",
    "AnalyticsMetadata": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword"

payload <- "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword";

    let payload = json!({
        "ClientId": "",
        "SecretHash": "",
        "UserContextData": "",
        "Username": "",
        "AnalyticsMetadata": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}'

echo '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientId": "",\n  "SecretHash": "",\n  "UserContextData": "",\n  "Username": "",\n  "AnalyticsMetadata": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ForgotPassword")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetCSVHeader

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.GetCSVHeader');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetCSVHeader',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetCSVHeader',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.GetCSVHeader';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetCSVHeader', [
  'body' => '{
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader"

payload = { "UserPoolId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader"

payload <- "{\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader";

    let payload = json!({"UserPoolId": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": ""
}'

echo '{
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["UserPoolId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetCSVHeader")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetDevice

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice

HEADERS

X-Amz-Target

BODY json

{
  "DeviceKey": "",
  "AccessToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:DeviceKey ""
                                                                                                                    :AccessToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice"

	payload := strings.NewReader("{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "DeviceKey": "",
  "AccessToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DeviceKey: '',
  AccessToken: ''
});

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=AWSCognitoIdentityProviderService.GetDevice');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DeviceKey: '', AccessToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeviceKey":"","AccessToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetDevice',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceKey": "",\n  "AccessToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({DeviceKey: '', AccessToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DeviceKey: '', AccessToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DeviceKey: '',
  AccessToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetDevice',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DeviceKey: '', AccessToken: ''}
};

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=AWSCognitoIdentityProviderService.GetDevice';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeviceKey":"","AccessToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DeviceKey": @"",
                              @"AccessToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DeviceKey' => '',
    'AccessToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetDevice', [
  'body' => '{
  "DeviceKey": "",
  "AccessToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceKey' => '',
  'AccessToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DeviceKey' => '',
  'AccessToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceKey": "",
  "AccessToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceKey": "",
  "AccessToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice"

payload = {
    "DeviceKey": "",
    "AccessToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice"

payload <- "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DeviceKey\": \"\",\n  \"AccessToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice";

    let payload = json!({
        "DeviceKey": "",
        "AccessToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DeviceKey": "",
  "AccessToken": ""
}'

echo '{
  "DeviceKey": "",
  "AccessToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceKey": "",\n  "AccessToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DeviceKey": "",
  "AccessToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetDevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetGroup

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup

HEADERS

X-Amz-Target

BODY json

{
  "GroupName": "",
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:GroupName ""
                                                                                                                   :UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup"

	payload := strings.NewReader("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "GroupName": "",
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GroupName: '',
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.GetGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GroupName": "",\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({GroupName: '', UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GroupName: '', UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GroupName: '',
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.GetGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GroupName": @"",
                              @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'GroupName' => '',
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetGroup', [
  'body' => '{
  "GroupName": "",
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GroupName' => '',
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GroupName' => '',
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup"

payload = {
    "GroupName": "",
    "UserPoolId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup"

payload <- "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup";

    let payload = json!({
        "GroupName": "",
        "UserPoolId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GroupName": "",
  "UserPoolId": ""
}'

echo '{
  "GroupName": "",
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GroupName": "",\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GroupName": "",
  "UserPoolId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetIdentityProviderByIdentifier

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "IdpIdentifier": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier" {:headers {:x-amz-target ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:UserPoolId ""
                                                                                                                                          :IdpIdentifier ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "UserPoolId": "",
  "IdpIdentifier": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  IdpIdentifier: ''
});

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=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', IdpIdentifier: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","IdpIdentifier":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "IdpIdentifier": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', IdpIdentifier: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', IdpIdentifier: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  IdpIdentifier: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', IdpIdentifier: ''}
};

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=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","IdpIdentifier":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"IdpIdentifier": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'IdpIdentifier' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier', [
  'body' => '{
  "UserPoolId": "",
  "IdpIdentifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'IdpIdentifier' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'IdpIdentifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "IdpIdentifier": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "IdpIdentifier": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier"

payload = {
    "UserPoolId": "",
    "IdpIdentifier": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"IdpIdentifier\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier";

    let payload = json!({
        "UserPoolId": "",
        "IdpIdentifier": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "IdpIdentifier": ""
}'

echo '{
  "UserPoolId": "",
  "IdpIdentifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "IdpIdentifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "IdpIdentifier": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetSigningCertificate

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.GetSigningCertificate');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetSigningCertificate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetSigningCertificate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.GetSigningCertificate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetSigningCertificate', [
  'body' => '{
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate"

payload = { "UserPoolId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate"

payload <- "{\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate";

    let payload = json!({"UserPoolId": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": ""
}'

echo '{
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["UserPoolId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetSigningCertificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetUICustomization

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:UserPoolId ""
                                                                                                                             :ClientId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "UserPoolId": "",
  "ClientId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: ''
});

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=AWSCognitoIdentityProviderService.GetUICustomization');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetUICustomization',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', ClientId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', ClientId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetUICustomization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: ''}
};

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=AWSCognitoIdentityProviderService.GetUICustomization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetUICustomization', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization"

payload = {
    "UserPoolId": "",
    "ClientId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUICustomization")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetUser

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:AccessToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "AccessToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: ''
});

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=AWSCognitoIdentityProviderService.GetUser');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetUser',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetUser',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: ''}
};

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=AWSCognitoIdentityProviderService.GetUser';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetUser', [
  'body' => '{
  "AccessToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser"

payload = { "AccessToken": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser"

payload <- "{\n  \"AccessToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser";

    let payload = json!({"AccessToken": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": ""
}'

echo '{
  "AccessToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["AccessToken": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetUserAttributeVerificationCode

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:AccessToken ""
                                                                                                                                           :AttributeName ""
                                                                                                                                           :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  AttributeName: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', AttributeName: '', ClientMetadata: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","AttributeName":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "AttributeName": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', AttributeName: '', ClientMetadata: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', AttributeName: '', ClientMetadata: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  AttributeName: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', AttributeName: '', ClientMetadata: ''}
};

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=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","AttributeName":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"AttributeName": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'AttributeName' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode', [
  'body' => '{
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'AttributeName' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'AttributeName' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode"

payload = {
    "AccessToken": "",
    "AttributeName": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode"

payload <- "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode";

    let payload = json!({
        "AccessToken": "",
        "AttributeName": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
}'

echo '{
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "AttributeName": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "AttributeName": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetUserPoolMfaConfig

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "UserPoolId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: ''
});

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=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: ''}
};

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=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig', [
  'body' => '{
  "UserPoolId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig"

payload = { "UserPoolId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig"

payload <- "{\n  \"UserPoolId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig";

    let payload = json!({"UserPoolId": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": ""
}'

echo '{
  "UserPoolId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["UserPoolId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GetUserPoolMfaConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GlobalSignOut

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:AccessToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "AccessToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: ''
});

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=AWSCognitoIdentityProviderService.GlobalSignOut');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.GlobalSignOut',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.GlobalSignOut',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: ''}
};

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=AWSCognitoIdentityProviderService.GlobalSignOut';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.GlobalSignOut', [
  'body' => '{
  "AccessToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut"

payload = { "AccessToken": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut"

payload <- "{\n  \"AccessToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut";

    let payload = json!({"AccessToken": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": ""
}'

echo '{
  "AccessToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["AccessToken": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.GlobalSignOut")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST InitiateAuth

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth

HEADERS

X-Amz-Target

BODY json

{
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:AuthFlow ""
                                                                                                                       :AuthParameters ""
                                                                                                                       :ClientMetadata ""
                                                                                                                       :ClientId ""
                                                                                                                       :AnalyticsMetadata ""
                                                                                                                       :UserContextData ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth"

	payload := strings.NewReader("{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 138

{
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AuthFlow: '',
  AuthParameters: '',
  ClientMetadata: '',
  ClientId: '',
  AnalyticsMetadata: '',
  UserContextData: ''
});

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=AWSCognitoIdentityProviderService.InitiateAuth');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AuthFlow: '',
    AuthParameters: '',
    ClientMetadata: '',
    ClientId: '',
    AnalyticsMetadata: '',
    UserContextData: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AuthFlow":"","AuthParameters":"","ClientMetadata":"","ClientId":"","AnalyticsMetadata":"","UserContextData":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.InitiateAuth',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AuthFlow": "",\n  "AuthParameters": "",\n  "ClientMetadata": "",\n  "ClientId": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  AuthFlow: '',
  AuthParameters: '',
  ClientMetadata: '',
  ClientId: '',
  AnalyticsMetadata: '',
  UserContextData: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AuthFlow: '',
    AuthParameters: '',
    ClientMetadata: '',
    ClientId: '',
    AnalyticsMetadata: '',
    UserContextData: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AuthFlow: '',
  AuthParameters: '',
  ClientMetadata: '',
  ClientId: '',
  AnalyticsMetadata: '',
  UserContextData: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.InitiateAuth',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AuthFlow: '',
    AuthParameters: '',
    ClientMetadata: '',
    ClientId: '',
    AnalyticsMetadata: '',
    UserContextData: ''
  }
};

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=AWSCognitoIdentityProviderService.InitiateAuth';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AuthFlow":"","AuthParameters":"","ClientMetadata":"","ClientId":"","AnalyticsMetadata":"","UserContextData":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AuthFlow": @"",
                              @"AuthParameters": @"",
                              @"ClientMetadata": @"",
                              @"ClientId": @"",
                              @"AnalyticsMetadata": @"",
                              @"UserContextData": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AuthFlow' => '',
    'AuthParameters' => '',
    'ClientMetadata' => '',
    'ClientId' => '',
    'AnalyticsMetadata' => '',
    'UserContextData' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.InitiateAuth', [
  'body' => '{
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AuthFlow' => '',
  'AuthParameters' => '',
  'ClientMetadata' => '',
  'ClientId' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AuthFlow' => '',
  'AuthParameters' => '',
  'ClientMetadata' => '',
  'ClientId' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth"

payload = {
    "AuthFlow": "",
    "AuthParameters": "",
    "ClientMetadata": "",
    "ClientId": "",
    "AnalyticsMetadata": "",
    "UserContextData": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth"

payload <- "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AuthFlow\": \"\",\n  \"AuthParameters\": \"\",\n  \"ClientMetadata\": \"\",\n  \"ClientId\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth";

    let payload = json!({
        "AuthFlow": "",
        "AuthParameters": "",
        "ClientMetadata": "",
        "ClientId": "",
        "AnalyticsMetadata": "",
        "UserContextData": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
}'

echo '{
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AuthFlow": "",\n  "AuthParameters": "",\n  "ClientMetadata": "",\n  "ClientId": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AuthFlow": "",
  "AuthParameters": "",
  "ClientMetadata": "",
  "ClientId": "",
  "AnalyticsMetadata": "",
  "UserContextData": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.InitiateAuth")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListDevices

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:AccessToken ""
                                                                                                                      :Limit ""
                                                                                                                      :PaginationToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  Limit: '',
  PaginationToken: ''
});

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=AWSCognitoIdentityProviderService.ListDevices');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', Limit: '', PaginationToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","Limit":"","PaginationToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListDevices',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "Limit": "",\n  "PaginationToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', Limit: '', PaginationToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', Limit: '', PaginationToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  Limit: '',
  PaginationToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', Limit: '', PaginationToken: ''}
};

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=AWSCognitoIdentityProviderService.ListDevices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","Limit":"","PaginationToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"Limit": @"",
                              @"PaginationToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'Limit' => '',
    'PaginationToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListDevices', [
  'body' => '{
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'Limit' => '',
  'PaginationToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'Limit' => '',
  'PaginationToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices"

payload = {
    "AccessToken": "",
    "Limit": "",
    "PaginationToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices"

payload <- "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices";

    let payload = json!({
        "AccessToken": "",
        "Limit": "",
        "PaginationToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
}'

echo '{
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "Limit": "",\n  "PaginationToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "Limit": "",
  "PaginationToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListDevices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListGroups

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:UserPoolId ""
                                                                                                                     :Limit ""
                                                                                                                     :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Limit: '',
  NextToken: ''
});

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=AWSCognitoIdentityProviderService.ListGroups');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Limit: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Limit":"","NextToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListGroups',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Limit": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Limit: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Limit: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Limit: '',
  NextToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Limit: '', NextToken: ''}
};

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=AWSCognitoIdentityProviderService.ListGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Limit":"","NextToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Limit": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Limit' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListGroups', [
  'body' => '{
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Limit' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Limit' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups"

payload = {
    "UserPoolId": "",
    "Limit": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups";

    let payload = json!({
        "UserPoolId": "",
        "Limit": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}'

echo '{
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Limit": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Limit": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListGroups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListIdentityProviders

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:UserPoolId ""
                                                                                                                                :MaxResults ""
                                                                                                                                :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  MaxResults: '',
  NextToken: ''
});

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=AWSCognitoIdentityProviderService.ListIdentityProviders');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListIdentityProviders',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListIdentityProviders',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', NextToken: ''}
};

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=AWSCognitoIdentityProviderService.ListIdentityProviders';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","NextToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListIdentityProviders', [
  'body' => '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders"

payload = {
    "UserPoolId": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders";

    let payload = json!({
        "UserPoolId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListIdentityProviders")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListResourceServers

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:UserPoolId ""
                                                                                                                              :MaxResults ""
                                                                                                                              :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  MaxResults: '',
  NextToken: ''
});

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=AWSCognitoIdentityProviderService.ListResourceServers');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListResourceServers',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListResourceServers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', NextToken: ''}
};

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=AWSCognitoIdentityProviderService.ListResourceServers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","NextToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListResourceServers', [
  'body' => '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers"

payload = {
    "UserPoolId": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers";

    let payload = json!({
        "UserPoolId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListResourceServers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListTagsForResource

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:ResourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "ResourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ResourceArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

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=AWSCognitoIdentityProviderService.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ResourceArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListTagsForResource', [
  'body' => '{
  "ResourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource"

payload = { "ResourceArn": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource"

payload <- "{\n  \"ResourceArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource";

    let payload = json!({"ResourceArn": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": ""
}'

echo '{
  "ResourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["ResourceArn": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListTagsForResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListUserImportJobs

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:UserPoolId ""
                                                                                                                             :MaxResults ""
                                                                                                                             :PaginationToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 67

{
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  MaxResults: '',
  PaginationToken: ''
});

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=AWSCognitoIdentityProviderService.ListUserImportJobs');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', PaginationToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","PaginationToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListUserImportJobs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "PaginationToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', MaxResults: '', PaginationToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', MaxResults: '', PaginationToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  MaxResults: '',
  PaginationToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListUserImportJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', PaginationToken: ''}
};

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=AWSCognitoIdentityProviderService.ListUserImportJobs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","PaginationToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"MaxResults": @"",
                              @"PaginationToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'MaxResults' => '',
    'PaginationToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListUserImportJobs', [
  'body' => '{
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'PaginationToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'PaginationToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs"

payload = {
    "UserPoolId": "",
    "MaxResults": "",
    "PaginationToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"PaginationToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs";

    let payload = json!({
        "UserPoolId": "",
        "MaxResults": "",
        "PaginationToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
}'

echo '{
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "PaginationToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "MaxResults": "",
  "PaginationToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserImportJobs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListUserPoolClients

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:UserPoolId ""
                                                                                                                              :MaxResults ""
                                                                                                                              :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  MaxResults: '',
  NextToken: ''
});

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=AWSCognitoIdentityProviderService.ListUserPoolClients');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListUserPoolClients',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListUserPoolClients',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', MaxResults: '', NextToken: ''}
};

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=AWSCognitoIdentityProviderService.ListUserPoolClients';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","MaxResults":"","NextToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListUserPoolClients', [
  'body' => '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients"

payload = {
    "UserPoolId": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients";

    let payload = json!({
        "UserPoolId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPoolClients")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListUserPools

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:NextToken ""
                                                                                                                        :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: ''
});

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=AWSCognitoIdentityProviderService.ListUserPools');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListUserPools',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  NextToken: '',
  MaxResults: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListUserPools',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: ''}
};

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=AWSCognitoIdentityProviderService.ListUserPools';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListUserPools', [
  'body' => '{
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools"

payload = {
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools";

    let payload = json!({
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUserPools")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListUsers

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:UserPoolId ""
                                                                                                                    :AttributesToGet ""
                                                                                                                    :Limit ""
                                                                                                                    :PaginationToken ""
                                                                                                                    :Filter ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 103

{
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  AttributesToGet: '',
  Limit: '',
  PaginationToken: '',
  Filter: ''
});

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=AWSCognitoIdentityProviderService.ListUsers');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    AttributesToGet: '',
    Limit: '',
    PaginationToken: '',
    Filter: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","AttributesToGet":"","Limit":"","PaginationToken":"","Filter":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListUsers',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "AttributesToGet": "",\n  "Limit": "",\n  "PaginationToken": "",\n  "Filter": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  AttributesToGet: '',
  Limit: '',
  PaginationToken: '',
  Filter: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    AttributesToGet: '',
    Limit: '',
    PaginationToken: '',
    Filter: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  AttributesToGet: '',
  Limit: '',
  PaginationToken: '',
  Filter: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListUsers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    AttributesToGet: '',
    Limit: '',
    PaginationToken: '',
    Filter: ''
  }
};

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=AWSCognitoIdentityProviderService.ListUsers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","AttributesToGet":"","Limit":"","PaginationToken":"","Filter":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"AttributesToGet": @"",
                              @"Limit": @"",
                              @"PaginationToken": @"",
                              @"Filter": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'AttributesToGet' => '',
    'Limit' => '',
    'PaginationToken' => '',
    'Filter' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListUsers', [
  'body' => '{
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'AttributesToGet' => '',
  'Limit' => '',
  'PaginationToken' => '',
  'Filter' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'AttributesToGet' => '',
  'Limit' => '',
  'PaginationToken' => '',
  'Filter' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers"

payload = {
    "UserPoolId": "",
    "AttributesToGet": "",
    "Limit": "",
    "PaginationToken": "",
    "Filter": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"PaginationToken\": \"\",\n  \"Filter\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers";

    let payload = json!({
        "UserPoolId": "",
        "AttributesToGet": "",
        "Limit": "",
        "PaginationToken": "",
        "Filter": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
}'

echo '{
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "AttributesToGet": "",\n  "Limit": "",\n  "PaginationToken": "",\n  "Filter": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "AttributesToGet": "",
  "Limit": "",
  "PaginationToken": "",
  "Filter": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListUsersInGroup

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:UserPoolId ""
                                                                                                                           :GroupName ""
                                                                                                                           :Limit ""
                                                                                                                           :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  GroupName: '',
  Limit: '',
  NextToken: ''
});

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=AWSCognitoIdentityProviderService.ListUsersInGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', GroupName: '', Limit: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","GroupName":"","Limit":"","NextToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ListUsersInGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "GroupName": "",\n  "Limit": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', GroupName: '', Limit: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', GroupName: '', Limit: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  GroupName: '',
  Limit: '',
  NextToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ListUsersInGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', GroupName: '', Limit: '', NextToken: ''}
};

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=AWSCognitoIdentityProviderService.ListUsersInGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","GroupName":"","Limit":"","NextToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"GroupName": @"",
                              @"Limit": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'GroupName' => '',
    'Limit' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ListUsersInGroup', [
  'body' => '{
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'GroupName' => '',
  'Limit' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'GroupName' => '',
  'Limit' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup"

payload = {
    "UserPoolId": "",
    "GroupName": "",
    "Limit": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"GroupName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup";

    let payload = json!({
        "UserPoolId": "",
        "GroupName": "",
        "Limit": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
}'

echo '{
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "GroupName": "",\n  "Limit": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "GroupName": "",
  "Limit": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ListUsersInGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ResendConfirmationCode

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode

HEADERS

X-Amz-Target

BODY json

{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:ClientId ""
                                                                                                                                 :SecretHash ""
                                                                                                                                 :UserContextData ""
                                                                                                                                 :Username ""
                                                                                                                                 :AnalyticsMetadata ""
                                                                                                                                 :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode"

	payload := strings.NewReader("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 134

{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientId: '',
  SecretHash: '',
  UserContextData: '',
  Username: '',
  AnalyticsMetadata: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.ResendConfirmationCode');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    UserContextData: '',
    Username: '',
    AnalyticsMetadata: '',
    ClientMetadata: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","UserContextData":"","Username":"","AnalyticsMetadata":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.ResendConfirmationCode',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientId": "",\n  "SecretHash": "",\n  "UserContextData": "",\n  "Username": "",\n  "AnalyticsMetadata": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ClientId: '',
  SecretHash: '',
  UserContextData: '',
  Username: '',
  AnalyticsMetadata: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientId: '',
    SecretHash: '',
    UserContextData: '',
    Username: '',
    AnalyticsMetadata: '',
    ClientMetadata: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ClientId: '',
  SecretHash: '',
  UserContextData: '',
  Username: '',
  AnalyticsMetadata: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.ResendConfirmationCode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    UserContextData: '',
    Username: '',
    AnalyticsMetadata: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.ResendConfirmationCode';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","UserContextData":"","Username":"","AnalyticsMetadata":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientId": @"",
                              @"SecretHash": @"",
                              @"UserContextData": @"",
                              @"Username": @"",
                              @"AnalyticsMetadata": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ClientId' => '',
    'SecretHash' => '',
    'UserContextData' => '',
    'Username' => '',
    'AnalyticsMetadata' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.ResendConfirmationCode', [
  'body' => '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'UserContextData' => '',
  'Username' => '',
  'AnalyticsMetadata' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'UserContextData' => '',
  'Username' => '',
  'AnalyticsMetadata' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode"

payload = {
    "ClientId": "",
    "SecretHash": "",
    "UserContextData": "",
    "Username": "",
    "AnalyticsMetadata": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode"

payload <- "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"UserContextData\": \"\",\n  \"Username\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode";

    let payload = json!({
        "ClientId": "",
        "SecretHash": "",
        "UserContextData": "",
        "Username": "",
        "AnalyticsMetadata": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}'

echo '{
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientId": "",\n  "SecretHash": "",\n  "UserContextData": "",\n  "Username": "",\n  "AnalyticsMetadata": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientId": "",
  "SecretHash": "",
  "UserContextData": "",
  "Username": "",
  "AnalyticsMetadata": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.ResendConfirmationCode")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RespondToAuthChallenge

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge

HEADERS

X-Amz-Target

BODY json

{
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:ClientId ""
                                                                                                                                 :ChallengeName ""
                                                                                                                                 :Session ""
                                                                                                                                 :ChallengeResponses ""
                                                                                                                                 :AnalyticsMetadata ""
                                                                                                                                 :UserContextData ""
                                                                                                                                 :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge"

	payload := strings.NewReader("{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 164

{
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientId: '',
  ChallengeName: '',
  Session: '',
  ChallengeResponses: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.RespondToAuthChallenge');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    ChallengeName: '',
    Session: '',
    ChallengeResponses: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","ChallengeName":"","Session":"","ChallengeResponses":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.RespondToAuthChallenge',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientId": "",\n  "ChallengeName": "",\n  "Session": "",\n  "ChallengeResponses": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ClientId: '',
  ChallengeName: '',
  Session: '',
  ChallengeResponses: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientId: '',
    ChallengeName: '',
    Session: '',
    ChallengeResponses: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ClientId: '',
  ChallengeName: '',
  Session: '',
  ChallengeResponses: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.RespondToAuthChallenge',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    ChallengeName: '',
    Session: '',
    ChallengeResponses: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.RespondToAuthChallenge';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","ChallengeName":"","Session":"","ChallengeResponses":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientId": @"",
                              @"ChallengeName": @"",
                              @"Session": @"",
                              @"ChallengeResponses": @"",
                              @"AnalyticsMetadata": @"",
                              @"UserContextData": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ClientId' => '',
    'ChallengeName' => '',
    'Session' => '',
    'ChallengeResponses' => '',
    'AnalyticsMetadata' => '',
    'UserContextData' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.RespondToAuthChallenge', [
  'body' => '{
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientId' => '',
  'ChallengeName' => '',
  'Session' => '',
  'ChallengeResponses' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ClientId' => '',
  'ChallengeName' => '',
  'Session' => '',
  'ChallengeResponses' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge"

payload = {
    "ClientId": "",
    "ChallengeName": "",
    "Session": "",
    "ChallengeResponses": "",
    "AnalyticsMetadata": "",
    "UserContextData": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge"

payload <- "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientId\": \"\",\n  \"ChallengeName\": \"\",\n  \"Session\": \"\",\n  \"ChallengeResponses\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge";

    let payload = json!({
        "ClientId": "",
        "ChallengeName": "",
        "Session": "",
        "ChallengeResponses": "",
        "AnalyticsMetadata": "",
        "UserContextData": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

echo '{
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientId": "",\n  "ChallengeName": "",\n  "Session": "",\n  "ChallengeResponses": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientId": "",
  "ChallengeName": "",
  "Session": "",
  "ChallengeResponses": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RespondToAuthChallenge")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RevokeToken

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken

HEADERS

X-Amz-Target

BODY json

{
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:Token ""
                                                                                                                      :ClientId ""
                                                                                                                      :ClientSecret ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken"

	payload := strings.NewReader("{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Token: '',
  ClientId: '',
  ClientSecret: ''
});

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=AWSCognitoIdentityProviderService.RevokeToken');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Token: '', ClientId: '', ClientSecret: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Token":"","ClientId":"","ClientSecret":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.RevokeToken',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Token": "",\n  "ClientId": "",\n  "ClientSecret": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Token: '', ClientId: '', ClientSecret: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Token: '', ClientId: '', ClientSecret: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Token: '',
  ClientId: '',
  ClientSecret: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.RevokeToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Token: '', ClientId: '', ClientSecret: ''}
};

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=AWSCognitoIdentityProviderService.RevokeToken';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Token":"","ClientId":"","ClientSecret":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Token": @"",
                              @"ClientId": @"",
                              @"ClientSecret": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Token' => '',
    'ClientId' => '',
    'ClientSecret' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.RevokeToken', [
  'body' => '{
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Token' => '',
  'ClientId' => '',
  'ClientSecret' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Token' => '',
  'ClientId' => '',
  'ClientSecret' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken"

payload = {
    "Token": "",
    "ClientId": "",
    "ClientSecret": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken"

payload <- "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Token\": \"\",\n  \"ClientId\": \"\",\n  \"ClientSecret\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken";

    let payload = json!({
        "Token": "",
        "ClientId": "",
        "ClientSecret": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
}'

echo '{
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Token": "",\n  "ClientId": "",\n  "ClientSecret": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Token": "",
  "ClientId": "",
  "ClientSecret": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.RevokeToken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SetRiskConfiguration

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :ClientId ""
                                                                                                                               :CompromisedCredentialsRiskConfiguration ""
                                                                                                                               :AccountTakeoverRiskConfiguration ""
                                                                                                                               :RiskExceptionConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 167

{
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  CompromisedCredentialsRiskConfiguration: '',
  AccountTakeoverRiskConfiguration: '',
  RiskExceptionConfiguration: ''
});

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=AWSCognitoIdentityProviderService.SetRiskConfiguration');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    CompromisedCredentialsRiskConfiguration: '',
    AccountTakeoverRiskConfiguration: '',
    RiskExceptionConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","CompromisedCredentialsRiskConfiguration":"","AccountTakeoverRiskConfiguration":"","RiskExceptionConfiguration":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.SetRiskConfiguration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "CompromisedCredentialsRiskConfiguration": "",\n  "AccountTakeoverRiskConfiguration": "",\n  "RiskExceptionConfiguration": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  CompromisedCredentialsRiskConfiguration: '',
  AccountTakeoverRiskConfiguration: '',
  RiskExceptionConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    ClientId: '',
    CompromisedCredentialsRiskConfiguration: '',
    AccountTakeoverRiskConfiguration: '',
    RiskExceptionConfiguration: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: '',
  CompromisedCredentialsRiskConfiguration: '',
  AccountTakeoverRiskConfiguration: '',
  RiskExceptionConfiguration: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.SetRiskConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    CompromisedCredentialsRiskConfiguration: '',
    AccountTakeoverRiskConfiguration: '',
    RiskExceptionConfiguration: ''
  }
};

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=AWSCognitoIdentityProviderService.SetRiskConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","CompromisedCredentialsRiskConfiguration":"","AccountTakeoverRiskConfiguration":"","RiskExceptionConfiguration":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"",
                              @"CompromisedCredentialsRiskConfiguration": @"",
                              @"AccountTakeoverRiskConfiguration": @"",
                              @"RiskExceptionConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => '',
    'CompromisedCredentialsRiskConfiguration' => '',
    'AccountTakeoverRiskConfiguration' => '',
    'RiskExceptionConfiguration' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.SetRiskConfiguration', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'CompromisedCredentialsRiskConfiguration' => '',
  'AccountTakeoverRiskConfiguration' => '',
  'RiskExceptionConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'CompromisedCredentialsRiskConfiguration' => '',
  'AccountTakeoverRiskConfiguration' => '',
  'RiskExceptionConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration"

payload = {
    "UserPoolId": "",
    "ClientId": "",
    "CompromisedCredentialsRiskConfiguration": "",
    "AccountTakeoverRiskConfiguration": "",
    "RiskExceptionConfiguration": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CompromisedCredentialsRiskConfiguration\": \"\",\n  \"AccountTakeoverRiskConfiguration\": \"\",\n  \"RiskExceptionConfiguration\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": "",
        "CompromisedCredentialsRiskConfiguration": "",
        "AccountTakeoverRiskConfiguration": "",
        "RiskExceptionConfiguration": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "CompromisedCredentialsRiskConfiguration": "",\n  "AccountTakeoverRiskConfiguration": "",\n  "RiskExceptionConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": "",
  "CompromisedCredentialsRiskConfiguration": "",
  "AccountTakeoverRiskConfiguration": "",
  "RiskExceptionConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetRiskConfiguration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SetUICustomization

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:UserPoolId ""
                                                                                                                             :ClientId ""
                                                                                                                             :CSS ""
                                                                                                                             :ImageFile ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  CSS: '',
  ImageFile: ''
});

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=AWSCognitoIdentityProviderService.SetUICustomization');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: '', CSS: '', ImageFile: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","CSS":"","ImageFile":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.SetUICustomization',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "CSS": "",\n  "ImageFile": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', ClientId: '', CSS: '', ImageFile: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', ClientId: '', CSS: '', ImageFile: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: '',
  CSS: '',
  ImageFile: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.SetUICustomization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', ClientId: '', CSS: '', ImageFile: ''}
};

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=AWSCognitoIdentityProviderService.SetUICustomization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","CSS":"","ImageFile":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"",
                              @"CSS": @"",
                              @"ImageFile": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => '',
    'CSS' => '',
    'ImageFile' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.SetUICustomization', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'CSS' => '',
  'ImageFile' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'CSS' => '',
  'ImageFile' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization"

payload = {
    "UserPoolId": "",
    "ClientId": "",
    "CSS": "",
    "ImageFile": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"CSS\": \"\",\n  \"ImageFile\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": "",
        "CSS": "",
        "ImageFile": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "CSS": "",\n  "ImageFile": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": "",
  "CSS": "",
  "ImageFile": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUICustomization")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SetUserMFAPreference

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference

HEADERS

X-Amz-Target

BODY json

{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:SMSMfaSettings ""
                                                                                                                               :SoftwareTokenMfaSettings ""
                                                                                                                               :AccessToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference"

	payload := strings.NewReader("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SMSMfaSettings: '',
  SoftwareTokenMfaSettings: '',
  AccessToken: ''
});

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=AWSCognitoIdentityProviderService.SetUserMFAPreference');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SMSMfaSettings: '', SoftwareTokenMfaSettings: '', AccessToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SMSMfaSettings":"","SoftwareTokenMfaSettings":"","AccessToken":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.SetUserMFAPreference',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SMSMfaSettings": "",\n  "SoftwareTokenMfaSettings": "",\n  "AccessToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({SMSMfaSettings: '', SoftwareTokenMfaSettings: '', AccessToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {SMSMfaSettings: '', SoftwareTokenMfaSettings: '', AccessToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SMSMfaSettings: '',
  SoftwareTokenMfaSettings: '',
  AccessToken: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.SetUserMFAPreference',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SMSMfaSettings: '', SoftwareTokenMfaSettings: '', AccessToken: ''}
};

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=AWSCognitoIdentityProviderService.SetUserMFAPreference';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SMSMfaSettings":"","SoftwareTokenMfaSettings":"","AccessToken":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SMSMfaSettings": @"",
                              @"SoftwareTokenMfaSettings": @"",
                              @"AccessToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'SMSMfaSettings' => '',
    'SoftwareTokenMfaSettings' => '',
    'AccessToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.SetUserMFAPreference', [
  'body' => '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SMSMfaSettings' => '',
  'SoftwareTokenMfaSettings' => '',
  'AccessToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SMSMfaSettings' => '',
  'SoftwareTokenMfaSettings' => '',
  'AccessToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference"

payload = {
    "SMSMfaSettings": "",
    "SoftwareTokenMfaSettings": "",
    "AccessToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference"

payload <- "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"SMSMfaSettings\": \"\",\n  \"SoftwareTokenMfaSettings\": \"\",\n  \"AccessToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference";

    let payload = json!({
        "SMSMfaSettings": "",
        "SoftwareTokenMfaSettings": "",
        "AccessToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
}'

echo '{
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SMSMfaSettings": "",\n  "SoftwareTokenMfaSettings": "",\n  "AccessToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SMSMfaSettings": "",
  "SoftwareTokenMfaSettings": "",
  "AccessToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserMFAPreference")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SetUserPoolMfaConfig

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :SmsMfaConfiguration ""
                                                                                                                               :SoftwareTokenMfaConfiguration ""
                                                                                                                               :MfaConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  SmsMfaConfiguration: '',
  SoftwareTokenMfaConfiguration: '',
  MfaConfiguration: ''
});

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=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    SmsMfaConfiguration: '',
    SoftwareTokenMfaConfiguration: '',
    MfaConfiguration: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","SmsMfaConfiguration":"","SoftwareTokenMfaConfiguration":"","MfaConfiguration":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "SmsMfaConfiguration": "",\n  "SoftwareTokenMfaConfiguration": "",\n  "MfaConfiguration": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  SmsMfaConfiguration: '',
  SoftwareTokenMfaConfiguration: '',
  MfaConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    SmsMfaConfiguration: '',
    SoftwareTokenMfaConfiguration: '',
    MfaConfiguration: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  SmsMfaConfiguration: '',
  SoftwareTokenMfaConfiguration: '',
  MfaConfiguration: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    SmsMfaConfiguration: '',
    SoftwareTokenMfaConfiguration: '',
    MfaConfiguration: ''
  }
};

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=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","SmsMfaConfiguration":"","SoftwareTokenMfaConfiguration":"","MfaConfiguration":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"SmsMfaConfiguration": @"",
                              @"SoftwareTokenMfaConfiguration": @"",
                              @"MfaConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'SmsMfaConfiguration' => '',
    'SoftwareTokenMfaConfiguration' => '',
    'MfaConfiguration' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig', [
  'body' => '{
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'SmsMfaConfiguration' => '',
  'SoftwareTokenMfaConfiguration' => '',
  'MfaConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'SmsMfaConfiguration' => '',
  'SoftwareTokenMfaConfiguration' => '',
  'MfaConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig"

payload = {
    "UserPoolId": "",
    "SmsMfaConfiguration": "",
    "SoftwareTokenMfaConfiguration": "",
    "MfaConfiguration": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"SmsMfaConfiguration\": \"\",\n  \"SoftwareTokenMfaConfiguration\": \"\",\n  \"MfaConfiguration\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig";

    let payload = json!({
        "UserPoolId": "",
        "SmsMfaConfiguration": "",
        "SoftwareTokenMfaConfiguration": "",
        "MfaConfiguration": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
}'

echo '{
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "SmsMfaConfiguration": "",\n  "SoftwareTokenMfaConfiguration": "",\n  "MfaConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "SmsMfaConfiguration": "",
  "SoftwareTokenMfaConfiguration": "",
  "MfaConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserPoolMfaConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SetUserSettings

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "MFAOptions": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:AccessToken ""
                                                                                                                          :MFAOptions ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "AccessToken": "",
  "MFAOptions": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  MFAOptions: ''
});

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=AWSCognitoIdentityProviderService.SetUserSettings');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', MFAOptions: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","MFAOptions":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.SetUserSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "MFAOptions": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', MFAOptions: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', MFAOptions: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  MFAOptions: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.SetUserSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', MFAOptions: ''}
};

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=AWSCognitoIdentityProviderService.SetUserSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","MFAOptions":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"MFAOptions": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'MFAOptions' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.SetUserSettings', [
  'body' => '{
  "AccessToken": "",
  "MFAOptions": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'MFAOptions' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'MFAOptions' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "MFAOptions": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "MFAOptions": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings"

payload = {
    "AccessToken": "",
    "MFAOptions": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings"

payload <- "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"MFAOptions\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings";

    let payload = json!({
        "AccessToken": "",
        "MFAOptions": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "MFAOptions": ""
}'

echo '{
  "AccessToken": "",
  "MFAOptions": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "MFAOptions": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "MFAOptions": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SetUserSettings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST SignUp

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp

HEADERS

X-Amz-Target

BODY json

{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:ClientId ""
                                                                                                                 :SecretHash ""
                                                                                                                 :Username ""
                                                                                                                 :Password ""
                                                                                                                 :UserAttributes ""
                                                                                                                 :ValidationData ""
                                                                                                                 :AnalyticsMetadata ""
                                                                                                                 :UserContextData ""
                                                                                                                 :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp"

	payload := strings.NewReader("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 200

{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientId: '',
  SecretHash: '',
  Username: '',
  Password: '',
  UserAttributes: '',
  ValidationData: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.SignUp');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    Password: '',
    UserAttributes: '',
    ValidationData: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","Username":"","Password":"","UserAttributes":"","ValidationData":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.SignUp',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientId": "",\n  "SecretHash": "",\n  "Username": "",\n  "Password": "",\n  "UserAttributes": "",\n  "ValidationData": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ClientId: '',
  SecretHash: '',
  Username: '',
  Password: '',
  UserAttributes: '',
  ValidationData: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    Password: '',
    UserAttributes: '',
    ValidationData: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ClientId: '',
  SecretHash: '',
  Username: '',
  Password: '',
  UserAttributes: '',
  ValidationData: '',
  AnalyticsMetadata: '',
  UserContextData: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.SignUp',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientId: '',
    SecretHash: '',
    Username: '',
    Password: '',
    UserAttributes: '',
    ValidationData: '',
    AnalyticsMetadata: '',
    UserContextData: '',
    ClientMetadata: ''
  }
};

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=AWSCognitoIdentityProviderService.SignUp';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientId":"","SecretHash":"","Username":"","Password":"","UserAttributes":"","ValidationData":"","AnalyticsMetadata":"","UserContextData":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientId": @"",
                              @"SecretHash": @"",
                              @"Username": @"",
                              @"Password": @"",
                              @"UserAttributes": @"",
                              @"ValidationData": @"",
                              @"AnalyticsMetadata": @"",
                              @"UserContextData": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ClientId' => '',
    'SecretHash' => '',
    'Username' => '',
    'Password' => '',
    'UserAttributes' => '',
    'ValidationData' => '',
    'AnalyticsMetadata' => '',
    'UserContextData' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.SignUp', [
  'body' => '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'Username' => '',
  'Password' => '',
  'UserAttributes' => '',
  'ValidationData' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ClientId' => '',
  'SecretHash' => '',
  'Username' => '',
  'Password' => '',
  'UserAttributes' => '',
  'ValidationData' => '',
  'AnalyticsMetadata' => '',
  'UserContextData' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp"

payload = {
    "ClientId": "",
    "SecretHash": "",
    "Username": "",
    "Password": "",
    "UserAttributes": "",
    "ValidationData": "",
    "AnalyticsMetadata": "",
    "UserContextData": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp"

payload <- "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientId\": \"\",\n  \"SecretHash\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"UserAttributes\": \"\",\n  \"ValidationData\": \"\",\n  \"AnalyticsMetadata\": \"\",\n  \"UserContextData\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp";

    let payload = json!({
        "ClientId": "",
        "SecretHash": "",
        "Username": "",
        "Password": "",
        "UserAttributes": "",
        "ValidationData": "",
        "AnalyticsMetadata": "",
        "UserContextData": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}'

echo '{
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientId": "",\n  "SecretHash": "",\n  "Username": "",\n  "Password": "",\n  "UserAttributes": "",\n  "ValidationData": "",\n  "AnalyticsMetadata": "",\n  "UserContextData": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientId": "",
  "SecretHash": "",
  "Username": "",
  "Password": "",
  "UserAttributes": "",
  "ValidationData": "",
  "AnalyticsMetadata": "",
  "UserContextData": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.SignUp")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartUserImportJob

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "JobId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:UserPoolId ""
                                                                                                                             :JobId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "UserPoolId": "",
  "JobId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  JobId: ''
});

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=AWSCognitoIdentityProviderService.StartUserImportJob');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', JobId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","JobId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.StartUserImportJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "JobId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', JobId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', JobId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  JobId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.StartUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', JobId: ''}
};

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=AWSCognitoIdentityProviderService.StartUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","JobId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"JobId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'JobId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.StartUserImportJob', [
  'body' => '{
  "UserPoolId": "",
  "JobId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'JobId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'JobId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "JobId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "JobId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob"

payload = {
    "UserPoolId": "",
    "JobId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob";

    let payload = json!({
        "UserPoolId": "",
        "JobId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "JobId": ""
}'

echo '{
  "UserPoolId": "",
  "JobId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "JobId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "JobId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StartUserImportJob")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopUserImportJob

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "JobId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:UserPoolId ""
                                                                                                                            :JobId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "UserPoolId": "",
  "JobId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  JobId: ''
});

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=AWSCognitoIdentityProviderService.StopUserImportJob');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', JobId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","JobId":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.StopUserImportJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "JobId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', JobId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', JobId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  JobId: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.StopUserImportJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', JobId: ''}
};

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=AWSCognitoIdentityProviderService.StopUserImportJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","JobId":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"JobId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'JobId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.StopUserImportJob', [
  'body' => '{
  "UserPoolId": "",
  "JobId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'JobId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'JobId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "JobId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "JobId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob"

payload = {
    "UserPoolId": "",
    "JobId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"JobId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob";

    let payload = json!({
        "UserPoolId": "",
        "JobId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "JobId": ""
}'

echo '{
  "UserPoolId": "",
  "JobId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "JobId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "JobId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.StopUserImportJob")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TagResource

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ResourceArn ""
                                                                                                                      :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "ResourceArn": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  Tags: ''
});

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=AWSCognitoIdentityProviderService.TagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","Tags":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.TagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "Tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ResourceArn: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', Tags: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  Tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","Tags":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceArn": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ResourceArn' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.TagResource', [
  'body' => '{
  "ResourceArn": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource"

payload = {
    "ResourceArn": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource";

    let payload = json!({
        "ResourceArn": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "Tags": ""
}'

echo '{
  "ResourceArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.TagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UntagResource

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": "",
  "TagKeys": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:ResourceArn ""
                                                                                                                        :TagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "ResourceArn": "",
  "TagKeys": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  TagKeys: ''
});

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=AWSCognitoIdentityProviderService.UntagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', TagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","TagKeys":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UntagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "TagKeys": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ResourceArn: '', TagKeys: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', TagKeys: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  TagKeys: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', TagKeys: ''}
};

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=AWSCognitoIdentityProviderService.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","TagKeys":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceArn": @"",
                              @"TagKeys": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ResourceArn' => '',
    'TagKeys' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UntagResource', [
  'body' => '{
  "ResourceArn": "",
  "TagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'TagKeys' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'TagKeys' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "TagKeys": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "TagKeys": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource"

payload = {
    "ResourceArn": "",
    "TagKeys": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource";

    let payload = json!({
        "ResourceArn": "",
        "TagKeys": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "TagKeys": ""
}'

echo '{
  "ResourceArn": "",
  "TagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": "",\n  "TagKeys": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "TagKeys": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UntagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateAuthEventFeedback

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:UserPoolId ""
                                                                                                                                  :Username ""
                                                                                                                                  :EventId ""
                                                                                                                                  :FeedbackToken ""
                                                                                                                                  :FeedbackValue ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 103

{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Username: '',
  EventId: '',
  FeedbackToken: '',
  FeedbackValue: ''
});

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=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    Username: '',
    EventId: '',
    FeedbackToken: '',
    FeedbackValue: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","EventId":"","FeedbackToken":"","FeedbackValue":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Username": "",\n  "EventId": "",\n  "FeedbackToken": "",\n  "FeedbackValue": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  Username: '',
  EventId: '',
  FeedbackToken: '',
  FeedbackValue: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    Username: '',
    EventId: '',
    FeedbackToken: '',
    FeedbackValue: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Username: '',
  EventId: '',
  FeedbackToken: '',
  FeedbackValue: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    Username: '',
    EventId: '',
    FeedbackToken: '',
    FeedbackValue: ''
  }
};

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=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Username":"","EventId":"","FeedbackToken":"","FeedbackValue":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Username": @"",
                              @"EventId": @"",
                              @"FeedbackToken": @"",
                              @"FeedbackValue": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Username' => '',
    'EventId' => '',
    'FeedbackToken' => '',
    'FeedbackValue' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback', [
  'body' => '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'EventId' => '',
  'FeedbackToken' => '',
  'FeedbackValue' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Username' => '',
  'EventId' => '',
  'FeedbackToken' => '',
  'FeedbackValue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback"

payload = {
    "UserPoolId": "",
    "Username": "",
    "EventId": "",
    "FeedbackToken": "",
    "FeedbackValue": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Username\": \"\",\n  \"EventId\": \"\",\n  \"FeedbackToken\": \"\",\n  \"FeedbackValue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback";

    let payload = json!({
        "UserPoolId": "",
        "Username": "",
        "EventId": "",
        "FeedbackToken": "",
        "FeedbackValue": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
}'

echo '{
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Username": "",\n  "EventId": "",\n  "FeedbackToken": "",\n  "FeedbackValue": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Username": "",
  "EventId": "",
  "FeedbackToken": "",
  "FeedbackValue": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateAuthEventFeedback")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateDeviceStatus

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:AccessToken ""
                                                                                                                             :DeviceKey ""
                                                                                                                             :DeviceRememberedStatus ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  DeviceKey: '',
  DeviceRememberedStatus: ''
});

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=AWSCognitoIdentityProviderService.UpdateDeviceStatus');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', DeviceKey: '', DeviceRememberedStatus: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","DeviceKey":"","DeviceRememberedStatus":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateDeviceStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "DeviceKey": "",\n  "DeviceRememberedStatus": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', DeviceKey: '', DeviceRememberedStatus: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', DeviceKey: '', DeviceRememberedStatus: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  DeviceKey: '',
  DeviceRememberedStatus: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateDeviceStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', DeviceKey: '', DeviceRememberedStatus: ''}
};

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=AWSCognitoIdentityProviderService.UpdateDeviceStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","DeviceKey":"","DeviceRememberedStatus":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"DeviceKey": @"",
                              @"DeviceRememberedStatus": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'DeviceKey' => '',
    'DeviceRememberedStatus' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateDeviceStatus', [
  'body' => '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'DeviceKey' => '',
  'DeviceRememberedStatus' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'DeviceKey' => '',
  'DeviceRememberedStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus"

payload = {
    "AccessToken": "",
    "DeviceKey": "",
    "DeviceRememberedStatus": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus"

payload <- "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"DeviceKey\": \"\",\n  \"DeviceRememberedStatus\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus";

    let payload = json!({
        "AccessToken": "",
        "DeviceKey": "",
        "DeviceRememberedStatus": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}'

echo '{
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "DeviceKey": "",\n  "DeviceRememberedStatus": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "DeviceKey": "",
  "DeviceRememberedStatus": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateDeviceStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateGroup

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup

HEADERS

X-Amz-Target

BODY json

{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:GroupName ""
                                                                                                                      :UserPoolId ""
                                                                                                                      :Description ""
                                                                                                                      :RoleArn ""
                                                                                                                      :Precedence ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup"

	payload := strings.NewReader("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 99

{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GroupName: '',
  UserPoolId: '',
  Description: '',
  RoleArn: '',
  Precedence: ''
});

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=AWSCognitoIdentityProviderService.UpdateGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":"","Description":"","RoleArn":"","Precedence":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GroupName": "",\n  "UserPoolId": "",\n  "Description": "",\n  "RoleArn": "",\n  "Precedence": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GroupName: '',
  UserPoolId: '',
  Description: '',
  RoleArn: '',
  Precedence: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GroupName: '', UserPoolId: '', Description: '', RoleArn: '', Precedence: ''}
};

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=AWSCognitoIdentityProviderService.UpdateGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GroupName":"","UserPoolId":"","Description":"","RoleArn":"","Precedence":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GroupName": @"",
                              @"UserPoolId": @"",
                              @"Description": @"",
                              @"RoleArn": @"",
                              @"Precedence": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'GroupName' => '',
    'UserPoolId' => '',
    'Description' => '',
    'RoleArn' => '',
    'Precedence' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateGroup', [
  'body' => '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GroupName' => '',
  'UserPoolId' => '',
  'Description' => '',
  'RoleArn' => '',
  'Precedence' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GroupName' => '',
  'UserPoolId' => '',
  'Description' => '',
  'RoleArn' => '',
  'Precedence' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup"

payload = {
    "GroupName": "",
    "UserPoolId": "",
    "Description": "",
    "RoleArn": "",
    "Precedence": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup"

payload <- "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GroupName\": \"\",\n  \"UserPoolId\": \"\",\n  \"Description\": \"\",\n  \"RoleArn\": \"\",\n  \"Precedence\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup";

    let payload = json!({
        "GroupName": "",
        "UserPoolId": "",
        "Description": "",
        "RoleArn": "",
        "Precedence": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}'

echo '{
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GroupName": "",\n  "UserPoolId": "",\n  "Description": "",\n  "RoleArn": "",\n  "Precedence": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GroupName": "",
  "UserPoolId": "",
  "Description": "",
  "RoleArn": "",
  "Precedence": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateIdentityProvider

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:UserPoolId ""
                                                                                                                                 :ProviderName ""
                                                                                                                                 :ProviderDetails ""
                                                                                                                                 :AttributeMapping ""
                                                                                                                                 :IdpIdentifiers ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 119

{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ProviderName: '',
  ProviderDetails: '',
  AttributeMapping: '',
  IdpIdentifiers: ''
});

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=AWSCognitoIdentityProviderService.UpdateIdentityProvider');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ProviderName: '',
    ProviderDetails: '',
    AttributeMapping: '',
    IdpIdentifiers: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":"","ProviderDetails":"","AttributeMapping":"","IdpIdentifiers":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateIdentityProvider',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ProviderName": "",\n  "ProviderDetails": "",\n  "AttributeMapping": "",\n  "IdpIdentifiers": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  ProviderName: '',
  ProviderDetails: '',
  AttributeMapping: '',
  IdpIdentifiers: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    ProviderName: '',
    ProviderDetails: '',
    AttributeMapping: '',
    IdpIdentifiers: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ProviderName: '',
  ProviderDetails: '',
  AttributeMapping: '',
  IdpIdentifiers: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateIdentityProvider',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ProviderName: '',
    ProviderDetails: '',
    AttributeMapping: '',
    IdpIdentifiers: ''
  }
};

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=AWSCognitoIdentityProviderService.UpdateIdentityProvider';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ProviderName":"","ProviderDetails":"","AttributeMapping":"","IdpIdentifiers":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ProviderName": @"",
                              @"ProviderDetails": @"",
                              @"AttributeMapping": @"",
                              @"IdpIdentifiers": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ProviderName' => '',
    'ProviderDetails' => '',
    'AttributeMapping' => '',
    'IdpIdentifiers' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateIdentityProvider', [
  'body' => '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ProviderName' => '',
  'ProviderDetails' => '',
  'AttributeMapping' => '',
  'IdpIdentifiers' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ProviderName' => '',
  'ProviderDetails' => '',
  'AttributeMapping' => '',
  'IdpIdentifiers' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider"

payload = {
    "UserPoolId": "",
    "ProviderName": "",
    "ProviderDetails": "",
    "AttributeMapping": "",
    "IdpIdentifiers": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ProviderName\": \"\",\n  \"ProviderDetails\": \"\",\n  \"AttributeMapping\": \"\",\n  \"IdpIdentifiers\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider";

    let payload = json!({
        "UserPoolId": "",
        "ProviderName": "",
        "ProviderDetails": "",
        "AttributeMapping": "",
        "IdpIdentifiers": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}'

echo '{
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ProviderName": "",\n  "ProviderDetails": "",\n  "AttributeMapping": "",\n  "IdpIdentifiers": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ProviderName": "",
  "ProviderDetails": "",
  "AttributeMapping": "",
  "IdpIdentifiers": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateIdentityProvider")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateResourceServer

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :Identifier ""
                                                                                                                               :Name ""
                                                                                                                               :Scopes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Identifier: '',
  Name: '',
  Scopes: ''
});

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=AWSCognitoIdentityProviderService.UpdateResourceServer');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: '', Name: '', Scopes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":"","Name":"","Scopes":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateResourceServer',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Identifier": "",\n  "Name": "",\n  "Scopes": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserPoolId: '', Identifier: '', Name: '', Scopes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserPoolId: '', Identifier: '', Name: '', Scopes: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Identifier: '',
  Name: '',
  Scopes: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateResourceServer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserPoolId: '', Identifier: '', Name: '', Scopes: ''}
};

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=AWSCognitoIdentityProviderService.UpdateResourceServer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Identifier":"","Name":"","Scopes":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Identifier": @"",
                              @"Name": @"",
                              @"Scopes": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Identifier' => '',
    'Name' => '',
    'Scopes' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateResourceServer', [
  'body' => '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Identifier' => '',
  'Name' => '',
  'Scopes' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Identifier' => '',
  'Name' => '',
  'Scopes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer"

payload = {
    "UserPoolId": "",
    "Identifier": "",
    "Name": "",
    "Scopes": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Identifier\": \"\",\n  \"Name\": \"\",\n  \"Scopes\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer";

    let payload = json!({
        "UserPoolId": "",
        "Identifier": "",
        "Name": "",
        "Scopes": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}'

echo '{
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Identifier": "",\n  "Name": "",\n  "Scopes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Identifier": "",
  "Name": "",
  "Scopes": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateResourceServer")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateUserAttributes

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes

HEADERS

X-Amz-Target

BODY json

{
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserAttributes ""
                                                                                                                               :AccessToken ""
                                                                                                                               :ClientMetadata ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes"

	payload := strings.NewReader("{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserAttributes: '',
  AccessToken: '',
  ClientMetadata: ''
});

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=AWSCognitoIdentityProviderService.UpdateUserAttributes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserAttributes: '', AccessToken: '', ClientMetadata: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserAttributes":"","AccessToken":"","ClientMetadata":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateUserAttributes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserAttributes": "",\n  "AccessToken": "",\n  "ClientMetadata": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({UserAttributes: '', AccessToken: '', ClientMetadata: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {UserAttributes: '', AccessToken: '', ClientMetadata: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserAttributes: '',
  AccessToken: '',
  ClientMetadata: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateUserAttributes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {UserAttributes: '', AccessToken: '', ClientMetadata: ''}
};

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=AWSCognitoIdentityProviderService.UpdateUserAttributes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserAttributes":"","AccessToken":"","ClientMetadata":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserAttributes": @"",
                              @"AccessToken": @"",
                              @"ClientMetadata": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserAttributes' => '',
    'AccessToken' => '',
    'ClientMetadata' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateUserAttributes', [
  'body' => '{
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserAttributes' => '',
  'AccessToken' => '',
  'ClientMetadata' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserAttributes' => '',
  'AccessToken' => '',
  'ClientMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes"

payload = {
    "UserAttributes": "",
    "AccessToken": "",
    "ClientMetadata": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes"

payload <- "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserAttributes\": \"\",\n  \"AccessToken\": \"\",\n  \"ClientMetadata\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes";

    let payload = json!({
        "UserAttributes": "",
        "AccessToken": "",
        "ClientMetadata": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
}'

echo '{
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserAttributes": "",\n  "AccessToken": "",\n  "ClientMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserAttributes": "",
  "AccessToken": "",
  "ClientMetadata": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserAttributes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateUserPool

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:UserPoolId ""
                                                                                                                         :Policies ""
                                                                                                                         :DeletionProtection ""
                                                                                                                         :LambdaConfig ""
                                                                                                                         :AutoVerifiedAttributes ""
                                                                                                                         :SmsVerificationMessage ""
                                                                                                                         :EmailVerificationMessage ""
                                                                                                                         :EmailVerificationSubject ""
                                                                                                                         :VerificationMessageTemplate ""
                                                                                                                         :SmsAuthenticationMessage ""
                                                                                                                         :UserAttributeUpdateSettings ""
                                                                                                                         :MfaConfiguration ""
                                                                                                                         :DeviceConfiguration ""
                                                                                                                         :EmailConfiguration ""
                                                                                                                         :SmsConfiguration ""
                                                                                                                         :UserPoolTags ""
                                                                                                                         :AdminCreateUserConfig ""
                                                                                                                         :UserPoolAddOns ""
                                                                                                                         :AccountRecoverySetting ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 548

{
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  Policies: '',
  DeletionProtection: '',
  LambdaConfig: '',
  AutoVerifiedAttributes: '',
  SmsVerificationMessage: '',
  EmailVerificationMessage: '',
  EmailVerificationSubject: '',
  VerificationMessageTemplate: '',
  SmsAuthenticationMessage: '',
  UserAttributeUpdateSettings: '',
  MfaConfiguration: '',
  DeviceConfiguration: '',
  EmailConfiguration: '',
  SmsConfiguration: '',
  UserPoolTags: '',
  AdminCreateUserConfig: '',
  UserPoolAddOns: '',
  AccountRecoverySetting: ''
});

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=AWSCognitoIdentityProviderService.UpdateUserPool');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    Policies: '',
    DeletionProtection: '',
    LambdaConfig: '',
    AutoVerifiedAttributes: '',
    SmsVerificationMessage: '',
    EmailVerificationMessage: '',
    EmailVerificationSubject: '',
    VerificationMessageTemplate: '',
    SmsAuthenticationMessage: '',
    UserAttributeUpdateSettings: '',
    MfaConfiguration: '',
    DeviceConfiguration: '',
    EmailConfiguration: '',
    SmsConfiguration: '',
    UserPoolTags: '',
    AdminCreateUserConfig: '',
    UserPoolAddOns: '',
    AccountRecoverySetting: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Policies":"","DeletionProtection":"","LambdaConfig":"","AutoVerifiedAttributes":"","SmsVerificationMessage":"","EmailVerificationMessage":"","EmailVerificationSubject":"","VerificationMessageTemplate":"","SmsAuthenticationMessage":"","UserAttributeUpdateSettings":"","MfaConfiguration":"","DeviceConfiguration":"","EmailConfiguration":"","SmsConfiguration":"","UserPoolTags":"","AdminCreateUserConfig":"","UserPoolAddOns":"","AccountRecoverySetting":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateUserPool',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "Policies": "",\n  "DeletionProtection": "",\n  "LambdaConfig": "",\n  "AutoVerifiedAttributes": "",\n  "SmsVerificationMessage": "",\n  "EmailVerificationMessage": "",\n  "EmailVerificationSubject": "",\n  "VerificationMessageTemplate": "",\n  "SmsAuthenticationMessage": "",\n  "UserAttributeUpdateSettings": "",\n  "MfaConfiguration": "",\n  "DeviceConfiguration": "",\n  "EmailConfiguration": "",\n  "SmsConfiguration": "",\n  "UserPoolTags": "",\n  "AdminCreateUserConfig": "",\n  "UserPoolAddOns": "",\n  "AccountRecoverySetting": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  Policies: '',
  DeletionProtection: '',
  LambdaConfig: '',
  AutoVerifiedAttributes: '',
  SmsVerificationMessage: '',
  EmailVerificationMessage: '',
  EmailVerificationSubject: '',
  VerificationMessageTemplate: '',
  SmsAuthenticationMessage: '',
  UserAttributeUpdateSettings: '',
  MfaConfiguration: '',
  DeviceConfiguration: '',
  EmailConfiguration: '',
  SmsConfiguration: '',
  UserPoolTags: '',
  AdminCreateUserConfig: '',
  UserPoolAddOns: '',
  AccountRecoverySetting: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    Policies: '',
    DeletionProtection: '',
    LambdaConfig: '',
    AutoVerifiedAttributes: '',
    SmsVerificationMessage: '',
    EmailVerificationMessage: '',
    EmailVerificationSubject: '',
    VerificationMessageTemplate: '',
    SmsAuthenticationMessage: '',
    UserAttributeUpdateSettings: '',
    MfaConfiguration: '',
    DeviceConfiguration: '',
    EmailConfiguration: '',
    SmsConfiguration: '',
    UserPoolTags: '',
    AdminCreateUserConfig: '',
    UserPoolAddOns: '',
    AccountRecoverySetting: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  Policies: '',
  DeletionProtection: '',
  LambdaConfig: '',
  AutoVerifiedAttributes: '',
  SmsVerificationMessage: '',
  EmailVerificationMessage: '',
  EmailVerificationSubject: '',
  VerificationMessageTemplate: '',
  SmsAuthenticationMessage: '',
  UserAttributeUpdateSettings: '',
  MfaConfiguration: '',
  DeviceConfiguration: '',
  EmailConfiguration: '',
  SmsConfiguration: '',
  UserPoolTags: '',
  AdminCreateUserConfig: '',
  UserPoolAddOns: '',
  AccountRecoverySetting: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateUserPool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    Policies: '',
    DeletionProtection: '',
    LambdaConfig: '',
    AutoVerifiedAttributes: '',
    SmsVerificationMessage: '',
    EmailVerificationMessage: '',
    EmailVerificationSubject: '',
    VerificationMessageTemplate: '',
    SmsAuthenticationMessage: '',
    UserAttributeUpdateSettings: '',
    MfaConfiguration: '',
    DeviceConfiguration: '',
    EmailConfiguration: '',
    SmsConfiguration: '',
    UserPoolTags: '',
    AdminCreateUserConfig: '',
    UserPoolAddOns: '',
    AccountRecoverySetting: ''
  }
};

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=AWSCognitoIdentityProviderService.UpdateUserPool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","Policies":"","DeletionProtection":"","LambdaConfig":"","AutoVerifiedAttributes":"","SmsVerificationMessage":"","EmailVerificationMessage":"","EmailVerificationSubject":"","VerificationMessageTemplate":"","SmsAuthenticationMessage":"","UserAttributeUpdateSettings":"","MfaConfiguration":"","DeviceConfiguration":"","EmailConfiguration":"","SmsConfiguration":"","UserPoolTags":"","AdminCreateUserConfig":"","UserPoolAddOns":"","AccountRecoverySetting":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"Policies": @"",
                              @"DeletionProtection": @"",
                              @"LambdaConfig": @"",
                              @"AutoVerifiedAttributes": @"",
                              @"SmsVerificationMessage": @"",
                              @"EmailVerificationMessage": @"",
                              @"EmailVerificationSubject": @"",
                              @"VerificationMessageTemplate": @"",
                              @"SmsAuthenticationMessage": @"",
                              @"UserAttributeUpdateSettings": @"",
                              @"MfaConfiguration": @"",
                              @"DeviceConfiguration": @"",
                              @"EmailConfiguration": @"",
                              @"SmsConfiguration": @"",
                              @"UserPoolTags": @"",
                              @"AdminCreateUserConfig": @"",
                              @"UserPoolAddOns": @"",
                              @"AccountRecoverySetting": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'Policies' => '',
    'DeletionProtection' => '',
    'LambdaConfig' => '',
    'AutoVerifiedAttributes' => '',
    'SmsVerificationMessage' => '',
    'EmailVerificationMessage' => '',
    'EmailVerificationSubject' => '',
    'VerificationMessageTemplate' => '',
    'SmsAuthenticationMessage' => '',
    'UserAttributeUpdateSettings' => '',
    'MfaConfiguration' => '',
    'DeviceConfiguration' => '',
    'EmailConfiguration' => '',
    'SmsConfiguration' => '',
    'UserPoolTags' => '',
    'AdminCreateUserConfig' => '',
    'UserPoolAddOns' => '',
    'AccountRecoverySetting' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateUserPool', [
  'body' => '{
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'Policies' => '',
  'DeletionProtection' => '',
  'LambdaConfig' => '',
  'AutoVerifiedAttributes' => '',
  'SmsVerificationMessage' => '',
  'EmailVerificationMessage' => '',
  'EmailVerificationSubject' => '',
  'VerificationMessageTemplate' => '',
  'SmsAuthenticationMessage' => '',
  'UserAttributeUpdateSettings' => '',
  'MfaConfiguration' => '',
  'DeviceConfiguration' => '',
  'EmailConfiguration' => '',
  'SmsConfiguration' => '',
  'UserPoolTags' => '',
  'AdminCreateUserConfig' => '',
  'UserPoolAddOns' => '',
  'AccountRecoverySetting' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'Policies' => '',
  'DeletionProtection' => '',
  'LambdaConfig' => '',
  'AutoVerifiedAttributes' => '',
  'SmsVerificationMessage' => '',
  'EmailVerificationMessage' => '',
  'EmailVerificationSubject' => '',
  'VerificationMessageTemplate' => '',
  'SmsAuthenticationMessage' => '',
  'UserAttributeUpdateSettings' => '',
  'MfaConfiguration' => '',
  'DeviceConfiguration' => '',
  'EmailConfiguration' => '',
  'SmsConfiguration' => '',
  'UserPoolTags' => '',
  'AdminCreateUserConfig' => '',
  'UserPoolAddOns' => '',
  'AccountRecoverySetting' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool"

payload = {
    "UserPoolId": "",
    "Policies": "",
    "DeletionProtection": "",
    "LambdaConfig": "",
    "AutoVerifiedAttributes": "",
    "SmsVerificationMessage": "",
    "EmailVerificationMessage": "",
    "EmailVerificationSubject": "",
    "VerificationMessageTemplate": "",
    "SmsAuthenticationMessage": "",
    "UserAttributeUpdateSettings": "",
    "MfaConfiguration": "",
    "DeviceConfiguration": "",
    "EmailConfiguration": "",
    "SmsConfiguration": "",
    "UserPoolTags": "",
    "AdminCreateUserConfig": "",
    "UserPoolAddOns": "",
    "AccountRecoverySetting": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"Policies\": \"\",\n  \"DeletionProtection\": \"\",\n  \"LambdaConfig\": \"\",\n  \"AutoVerifiedAttributes\": \"\",\n  \"SmsVerificationMessage\": \"\",\n  \"EmailVerificationMessage\": \"\",\n  \"EmailVerificationSubject\": \"\",\n  \"VerificationMessageTemplate\": \"\",\n  \"SmsAuthenticationMessage\": \"\",\n  \"UserAttributeUpdateSettings\": \"\",\n  \"MfaConfiguration\": \"\",\n  \"DeviceConfiguration\": \"\",\n  \"EmailConfiguration\": \"\",\n  \"SmsConfiguration\": \"\",\n  \"UserPoolTags\": \"\",\n  \"AdminCreateUserConfig\": \"\",\n  \"UserPoolAddOns\": \"\",\n  \"AccountRecoverySetting\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool";

    let payload = json!({
        "UserPoolId": "",
        "Policies": "",
        "DeletionProtection": "",
        "LambdaConfig": "",
        "AutoVerifiedAttributes": "",
        "SmsVerificationMessage": "",
        "EmailVerificationMessage": "",
        "EmailVerificationSubject": "",
        "VerificationMessageTemplate": "",
        "SmsAuthenticationMessage": "",
        "UserAttributeUpdateSettings": "",
        "MfaConfiguration": "",
        "DeviceConfiguration": "",
        "EmailConfiguration": "",
        "SmsConfiguration": "",
        "UserPoolTags": "",
        "AdminCreateUserConfig": "",
        "UserPoolAddOns": "",
        "AccountRecoverySetting": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
}'

echo '{
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "Policies": "",\n  "DeletionProtection": "",\n  "LambdaConfig": "",\n  "AutoVerifiedAttributes": "",\n  "SmsVerificationMessage": "",\n  "EmailVerificationMessage": "",\n  "EmailVerificationSubject": "",\n  "VerificationMessageTemplate": "",\n  "SmsAuthenticationMessage": "",\n  "UserAttributeUpdateSettings": "",\n  "MfaConfiguration": "",\n  "DeviceConfiguration": "",\n  "EmailConfiguration": "",\n  "SmsConfiguration": "",\n  "UserPoolTags": "",\n  "AdminCreateUserConfig": "",\n  "UserPoolAddOns": "",\n  "AccountRecoverySetting": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "Policies": "",
  "DeletionProtection": "",
  "LambdaConfig": "",
  "AutoVerifiedAttributes": "",
  "SmsVerificationMessage": "",
  "EmailVerificationMessage": "",
  "EmailVerificationSubject": "",
  "VerificationMessageTemplate": "",
  "SmsAuthenticationMessage": "",
  "UserAttributeUpdateSettings": "",
  "MfaConfiguration": "",
  "DeviceConfiguration": "",
  "EmailConfiguration": "",
  "SmsConfiguration": "",
  "UserPoolTags": "",
  "AdminCreateUserConfig": "",
  "UserPoolAddOns": "",
  "AccountRecoverySetting": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPool")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateUserPoolClient

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient

HEADERS

X-Amz-Target

BODY json

{
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:UserPoolId ""
                                                                                                                               :ClientId ""
                                                                                                                               :ClientName ""
                                                                                                                               :RefreshTokenValidity ""
                                                                                                                               :AccessTokenValidity ""
                                                                                                                               :IdTokenValidity ""
                                                                                                                               :TokenValidityUnits ""
                                                                                                                               :ReadAttributes ""
                                                                                                                               :WriteAttributes ""
                                                                                                                               :ExplicitAuthFlows ""
                                                                                                                               :SupportedIdentityProviders ""
                                                                                                                               :CallbackURLs ""
                                                                                                                               :LogoutURLs ""
                                                                                                                               :DefaultRedirectURI ""
                                                                                                                               :AllowedOAuthFlows ""
                                                                                                                               :AllowedOAuthScopes ""
                                                                                                                               :AllowedOAuthFlowsUserPoolClient ""
                                                                                                                               :AnalyticsConfiguration ""
                                                                                                                               :PreventUserExistenceErrors ""
                                                                                                                               :EnableTokenRevocation ""
                                                                                                                               :EnablePropagateAdditionalUserContextData ""
                                                                                                                               :AuthSessionValidity ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient"

	payload := strings.NewReader("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 628

{
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  ClientName: '',
  RefreshTokenValidity: '',
  AccessTokenValidity: '',
  IdTokenValidity: '',
  TokenValidityUnits: '',
  ReadAttributes: '',
  WriteAttributes: '',
  ExplicitAuthFlows: '',
  SupportedIdentityProviders: '',
  CallbackURLs: '',
  LogoutURLs: '',
  DefaultRedirectURI: '',
  AllowedOAuthFlows: '',
  AllowedOAuthScopes: '',
  AllowedOAuthFlowsUserPoolClient: '',
  AnalyticsConfiguration: '',
  PreventUserExistenceErrors: '',
  EnableTokenRevocation: '',
  EnablePropagateAdditionalUserContextData: '',
  AuthSessionValidity: ''
});

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=AWSCognitoIdentityProviderService.UpdateUserPoolClient');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    ClientName: '',
    RefreshTokenValidity: '',
    AccessTokenValidity: '',
    IdTokenValidity: '',
    TokenValidityUnits: '',
    ReadAttributes: '',
    WriteAttributes: '',
    ExplicitAuthFlows: '',
    SupportedIdentityProviders: '',
    CallbackURLs: '',
    LogoutURLs: '',
    DefaultRedirectURI: '',
    AllowedOAuthFlows: '',
    AllowedOAuthScopes: '',
    AllowedOAuthFlowsUserPoolClient: '',
    AnalyticsConfiguration: '',
    PreventUserExistenceErrors: '',
    EnableTokenRevocation: '',
    EnablePropagateAdditionalUserContextData: '',
    AuthSessionValidity: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","ClientName":"","RefreshTokenValidity":"","AccessTokenValidity":"","IdTokenValidity":"","TokenValidityUnits":"","ReadAttributes":"","WriteAttributes":"","ExplicitAuthFlows":"","SupportedIdentityProviders":"","CallbackURLs":"","LogoutURLs":"","DefaultRedirectURI":"","AllowedOAuthFlows":"","AllowedOAuthScopes":"","AllowedOAuthFlowsUserPoolClient":"","AnalyticsConfiguration":"","PreventUserExistenceErrors":"","EnableTokenRevocation":"","EnablePropagateAdditionalUserContextData":"","AuthSessionValidity":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateUserPoolClient',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "ClientName": "",\n  "RefreshTokenValidity": "",\n  "AccessTokenValidity": "",\n  "IdTokenValidity": "",\n  "TokenValidityUnits": "",\n  "ReadAttributes": "",\n  "WriteAttributes": "",\n  "ExplicitAuthFlows": "",\n  "SupportedIdentityProviders": "",\n  "CallbackURLs": "",\n  "LogoutURLs": "",\n  "DefaultRedirectURI": "",\n  "AllowedOAuthFlows": "",\n  "AllowedOAuthScopes": "",\n  "AllowedOAuthFlowsUserPoolClient": "",\n  "AnalyticsConfiguration": "",\n  "PreventUserExistenceErrors": "",\n  "EnableTokenRevocation": "",\n  "EnablePropagateAdditionalUserContextData": "",\n  "AuthSessionValidity": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  UserPoolId: '',
  ClientId: '',
  ClientName: '',
  RefreshTokenValidity: '',
  AccessTokenValidity: '',
  IdTokenValidity: '',
  TokenValidityUnits: '',
  ReadAttributes: '',
  WriteAttributes: '',
  ExplicitAuthFlows: '',
  SupportedIdentityProviders: '',
  CallbackURLs: '',
  LogoutURLs: '',
  DefaultRedirectURI: '',
  AllowedOAuthFlows: '',
  AllowedOAuthScopes: '',
  AllowedOAuthFlowsUserPoolClient: '',
  AnalyticsConfiguration: '',
  PreventUserExistenceErrors: '',
  EnableTokenRevocation: '',
  EnablePropagateAdditionalUserContextData: '',
  AuthSessionValidity: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserPoolId: '',
    ClientId: '',
    ClientName: '',
    RefreshTokenValidity: '',
    AccessTokenValidity: '',
    IdTokenValidity: '',
    TokenValidityUnits: '',
    ReadAttributes: '',
    WriteAttributes: '',
    ExplicitAuthFlows: '',
    SupportedIdentityProviders: '',
    CallbackURLs: '',
    LogoutURLs: '',
    DefaultRedirectURI: '',
    AllowedOAuthFlows: '',
    AllowedOAuthScopes: '',
    AllowedOAuthFlowsUserPoolClient: '',
    AnalyticsConfiguration: '',
    PreventUserExistenceErrors: '',
    EnableTokenRevocation: '',
    EnablePropagateAdditionalUserContextData: '',
    AuthSessionValidity: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  UserPoolId: '',
  ClientId: '',
  ClientName: '',
  RefreshTokenValidity: '',
  AccessTokenValidity: '',
  IdTokenValidity: '',
  TokenValidityUnits: '',
  ReadAttributes: '',
  WriteAttributes: '',
  ExplicitAuthFlows: '',
  SupportedIdentityProviders: '',
  CallbackURLs: '',
  LogoutURLs: '',
  DefaultRedirectURI: '',
  AllowedOAuthFlows: '',
  AllowedOAuthScopes: '',
  AllowedOAuthFlowsUserPoolClient: '',
  AnalyticsConfiguration: '',
  PreventUserExistenceErrors: '',
  EnableTokenRevocation: '',
  EnablePropagateAdditionalUserContextData: '',
  AuthSessionValidity: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateUserPoolClient',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserPoolId: '',
    ClientId: '',
    ClientName: '',
    RefreshTokenValidity: '',
    AccessTokenValidity: '',
    IdTokenValidity: '',
    TokenValidityUnits: '',
    ReadAttributes: '',
    WriteAttributes: '',
    ExplicitAuthFlows: '',
    SupportedIdentityProviders: '',
    CallbackURLs: '',
    LogoutURLs: '',
    DefaultRedirectURI: '',
    AllowedOAuthFlows: '',
    AllowedOAuthScopes: '',
    AllowedOAuthFlowsUserPoolClient: '',
    AnalyticsConfiguration: '',
    PreventUserExistenceErrors: '',
    EnableTokenRevocation: '',
    EnablePropagateAdditionalUserContextData: '',
    AuthSessionValidity: ''
  }
};

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=AWSCognitoIdentityProviderService.UpdateUserPoolClient';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserPoolId":"","ClientId":"","ClientName":"","RefreshTokenValidity":"","AccessTokenValidity":"","IdTokenValidity":"","TokenValidityUnits":"","ReadAttributes":"","WriteAttributes":"","ExplicitAuthFlows":"","SupportedIdentityProviders":"","CallbackURLs":"","LogoutURLs":"","DefaultRedirectURI":"","AllowedOAuthFlows":"","AllowedOAuthScopes":"","AllowedOAuthFlowsUserPoolClient":"","AnalyticsConfiguration":"","PreventUserExistenceErrors":"","EnableTokenRevocation":"","EnablePropagateAdditionalUserContextData":"","AuthSessionValidity":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserPoolId": @"",
                              @"ClientId": @"",
                              @"ClientName": @"",
                              @"RefreshTokenValidity": @"",
                              @"AccessTokenValidity": @"",
                              @"IdTokenValidity": @"",
                              @"TokenValidityUnits": @"",
                              @"ReadAttributes": @"",
                              @"WriteAttributes": @"",
                              @"ExplicitAuthFlows": @"",
                              @"SupportedIdentityProviders": @"",
                              @"CallbackURLs": @"",
                              @"LogoutURLs": @"",
                              @"DefaultRedirectURI": @"",
                              @"AllowedOAuthFlows": @"",
                              @"AllowedOAuthScopes": @"",
                              @"AllowedOAuthFlowsUserPoolClient": @"",
                              @"AnalyticsConfiguration": @"",
                              @"PreventUserExistenceErrors": @"",
                              @"EnableTokenRevocation": @"",
                              @"EnablePropagateAdditionalUserContextData": @"",
                              @"AuthSessionValidity": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'UserPoolId' => '',
    'ClientId' => '',
    'ClientName' => '',
    'RefreshTokenValidity' => '',
    'AccessTokenValidity' => '',
    'IdTokenValidity' => '',
    'TokenValidityUnits' => '',
    'ReadAttributes' => '',
    'WriteAttributes' => '',
    'ExplicitAuthFlows' => '',
    'SupportedIdentityProviders' => '',
    'CallbackURLs' => '',
    'LogoutURLs' => '',
    'DefaultRedirectURI' => '',
    'AllowedOAuthFlows' => '',
    'AllowedOAuthScopes' => '',
    'AllowedOAuthFlowsUserPoolClient' => '',
    'AnalyticsConfiguration' => '',
    'PreventUserExistenceErrors' => '',
    'EnableTokenRevocation' => '',
    'EnablePropagateAdditionalUserContextData' => '',
    'AuthSessionValidity' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateUserPoolClient', [
  'body' => '{
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'ClientName' => '',
  'RefreshTokenValidity' => '',
  'AccessTokenValidity' => '',
  'IdTokenValidity' => '',
  'TokenValidityUnits' => '',
  'ReadAttributes' => '',
  'WriteAttributes' => '',
  'ExplicitAuthFlows' => '',
  'SupportedIdentityProviders' => '',
  'CallbackURLs' => '',
  'LogoutURLs' => '',
  'DefaultRedirectURI' => '',
  'AllowedOAuthFlows' => '',
  'AllowedOAuthScopes' => '',
  'AllowedOAuthFlowsUserPoolClient' => '',
  'AnalyticsConfiguration' => '',
  'PreventUserExistenceErrors' => '',
  'EnableTokenRevocation' => '',
  'EnablePropagateAdditionalUserContextData' => '',
  'AuthSessionValidity' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'UserPoolId' => '',
  'ClientId' => '',
  'ClientName' => '',
  'RefreshTokenValidity' => '',
  'AccessTokenValidity' => '',
  'IdTokenValidity' => '',
  'TokenValidityUnits' => '',
  'ReadAttributes' => '',
  'WriteAttributes' => '',
  'ExplicitAuthFlows' => '',
  'SupportedIdentityProviders' => '',
  'CallbackURLs' => '',
  'LogoutURLs' => '',
  'DefaultRedirectURI' => '',
  'AllowedOAuthFlows' => '',
  'AllowedOAuthScopes' => '',
  'AllowedOAuthFlowsUserPoolClient' => '',
  'AnalyticsConfiguration' => '',
  'PreventUserExistenceErrors' => '',
  'EnableTokenRevocation' => '',
  'EnablePropagateAdditionalUserContextData' => '',
  'AuthSessionValidity' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient"

payload = {
    "UserPoolId": "",
    "ClientId": "",
    "ClientName": "",
    "RefreshTokenValidity": "",
    "AccessTokenValidity": "",
    "IdTokenValidity": "",
    "TokenValidityUnits": "",
    "ReadAttributes": "",
    "WriteAttributes": "",
    "ExplicitAuthFlows": "",
    "SupportedIdentityProviders": "",
    "CallbackURLs": "",
    "LogoutURLs": "",
    "DefaultRedirectURI": "",
    "AllowedOAuthFlows": "",
    "AllowedOAuthScopes": "",
    "AllowedOAuthFlowsUserPoolClient": "",
    "AnalyticsConfiguration": "",
    "PreventUserExistenceErrors": "",
    "EnableTokenRevocation": "",
    "EnablePropagateAdditionalUserContextData": "",
    "AuthSessionValidity": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient"

payload <- "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserPoolId\": \"\",\n  \"ClientId\": \"\",\n  \"ClientName\": \"\",\n  \"RefreshTokenValidity\": \"\",\n  \"AccessTokenValidity\": \"\",\n  \"IdTokenValidity\": \"\",\n  \"TokenValidityUnits\": \"\",\n  \"ReadAttributes\": \"\",\n  \"WriteAttributes\": \"\",\n  \"ExplicitAuthFlows\": \"\",\n  \"SupportedIdentityProviders\": \"\",\n  \"CallbackURLs\": \"\",\n  \"LogoutURLs\": \"\",\n  \"DefaultRedirectURI\": \"\",\n  \"AllowedOAuthFlows\": \"\",\n  \"AllowedOAuthScopes\": \"\",\n  \"AllowedOAuthFlowsUserPoolClient\": \"\",\n  \"AnalyticsConfiguration\": \"\",\n  \"PreventUserExistenceErrors\": \"\",\n  \"EnableTokenRevocation\": \"\",\n  \"EnablePropagateAdditionalUserContextData\": \"\",\n  \"AuthSessionValidity\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient";

    let payload = json!({
        "UserPoolId": "",
        "ClientId": "",
        "ClientName": "",
        "RefreshTokenValidity": "",
        "AccessTokenValidity": "",
        "IdTokenValidity": "",
        "TokenValidityUnits": "",
        "ReadAttributes": "",
        "WriteAttributes": "",
        "ExplicitAuthFlows": "",
        "SupportedIdentityProviders": "",
        "CallbackURLs": "",
        "LogoutURLs": "",
        "DefaultRedirectURI": "",
        "AllowedOAuthFlows": "",
        "AllowedOAuthScopes": "",
        "AllowedOAuthFlowsUserPoolClient": "",
        "AnalyticsConfiguration": "",
        "PreventUserExistenceErrors": "",
        "EnableTokenRevocation": "",
        "EnablePropagateAdditionalUserContextData": "",
        "AuthSessionValidity": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}'

echo '{
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserPoolId": "",\n  "ClientId": "",\n  "ClientName": "",\n  "RefreshTokenValidity": "",\n  "AccessTokenValidity": "",\n  "IdTokenValidity": "",\n  "TokenValidityUnits": "",\n  "ReadAttributes": "",\n  "WriteAttributes": "",\n  "ExplicitAuthFlows": "",\n  "SupportedIdentityProviders": "",\n  "CallbackURLs": "",\n  "LogoutURLs": "",\n  "DefaultRedirectURI": "",\n  "AllowedOAuthFlows": "",\n  "AllowedOAuthScopes": "",\n  "AllowedOAuthFlowsUserPoolClient": "",\n  "AnalyticsConfiguration": "",\n  "PreventUserExistenceErrors": "",\n  "EnableTokenRevocation": "",\n  "EnablePropagateAdditionalUserContextData": "",\n  "AuthSessionValidity": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserPoolId": "",
  "ClientId": "",
  "ClientName": "",
  "RefreshTokenValidity": "",
  "AccessTokenValidity": "",
  "IdTokenValidity": "",
  "TokenValidityUnits": "",
  "ReadAttributes": "",
  "WriteAttributes": "",
  "ExplicitAuthFlows": "",
  "SupportedIdentityProviders": "",
  "CallbackURLs": "",
  "LogoutURLs": "",
  "DefaultRedirectURI": "",
  "AllowedOAuthFlows": "",
  "AllowedOAuthScopes": "",
  "AllowedOAuthFlowsUserPoolClient": "",
  "AnalyticsConfiguration": "",
  "PreventUserExistenceErrors": "",
  "EnableTokenRevocation": "",
  "EnablePropagateAdditionalUserContextData": "",
  "AuthSessionValidity": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolClient")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateUserPoolDomain

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain

HEADERS

X-Amz-Target

BODY json

{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:Domain ""
                                                                                                                               :UserPoolId ""
                                                                                                                               :CustomDomainConfig ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain"

	payload := strings.NewReader("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Domain: '',
  UserPoolId: '',
  CustomDomainConfig: ''
});

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=AWSCognitoIdentityProviderService.UpdateUserPoolDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: '', UserPoolId: '', CustomDomainConfig: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":"","UserPoolId":"","CustomDomainConfig":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.UpdateUserPoolDomain',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Domain": "",\n  "UserPoolId": "",\n  "CustomDomainConfig": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Domain: '', UserPoolId: '', CustomDomainConfig: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Domain: '', UserPoolId: '', CustomDomainConfig: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Domain: '',
  UserPoolId: '',
  CustomDomainConfig: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.UpdateUserPoolDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Domain: '', UserPoolId: '', CustomDomainConfig: ''}
};

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=AWSCognitoIdentityProviderService.UpdateUserPoolDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Domain":"","UserPoolId":"","CustomDomainConfig":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Domain": @"",
                              @"UserPoolId": @"",
                              @"CustomDomainConfig": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Domain' => '',
    'UserPoolId' => '',
    'CustomDomainConfig' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.UpdateUserPoolDomain', [
  'body' => '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Domain' => '',
  'UserPoolId' => '',
  'CustomDomainConfig' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Domain' => '',
  'UserPoolId' => '',
  'CustomDomainConfig' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain"

payload = {
    "Domain": "",
    "UserPoolId": "",
    "CustomDomainConfig": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain"

payload <- "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Domain\": \"\",\n  \"UserPoolId\": \"\",\n  \"CustomDomainConfig\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain";

    let payload = json!({
        "Domain": "",
        "UserPoolId": "",
        "CustomDomainConfig": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}'

echo '{
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Domain": "",\n  "UserPoolId": "",\n  "CustomDomainConfig": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Domain": "",
  "UserPoolId": "",
  "CustomDomainConfig": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.UpdateUserPoolDomain")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST VerifySoftwareToken

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:AccessToken ""
                                                                                                                              :Session ""
                                                                                                                              :UserCode ""
                                                                                                                              :FriendlyDeviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  Session: '',
  UserCode: '',
  FriendlyDeviceName: ''
});

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=AWSCognitoIdentityProviderService.VerifySoftwareToken');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', Session: '', UserCode: '', FriendlyDeviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","Session":"","UserCode":"","FriendlyDeviceName":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.VerifySoftwareToken',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "Session": "",\n  "UserCode": "",\n  "FriendlyDeviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', Session: '', UserCode: '', FriendlyDeviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', Session: '', UserCode: '', FriendlyDeviceName: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  Session: '',
  UserCode: '',
  FriendlyDeviceName: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.VerifySoftwareToken',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', Session: '', UserCode: '', FriendlyDeviceName: ''}
};

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=AWSCognitoIdentityProviderService.VerifySoftwareToken';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","Session":"","UserCode":"","FriendlyDeviceName":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"Session": @"",
                              @"UserCode": @"",
                              @"FriendlyDeviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'Session' => '',
    'UserCode' => '',
    'FriendlyDeviceName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.VerifySoftwareToken', [
  'body' => '{
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'Session' => '',
  'UserCode' => '',
  'FriendlyDeviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'Session' => '',
  'UserCode' => '',
  'FriendlyDeviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken"

payload = {
    "AccessToken": "",
    "Session": "",
    "UserCode": "",
    "FriendlyDeviceName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken"

payload <- "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"Session\": \"\",\n  \"UserCode\": \"\",\n  \"FriendlyDeviceName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken";

    let payload = json!({
        "AccessToken": "",
        "Session": "",
        "UserCode": "",
        "FriendlyDeviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
}'

echo '{
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "Session": "",\n  "UserCode": "",\n  "FriendlyDeviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "Session": "",
  "UserCode": "",
  "FriendlyDeviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifySoftwareToken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST VerifyUserAttribute

{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute

HEADERS

X-Amz-Target

BODY json

{
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:AccessToken ""
                                                                                                                              :AttributeName ""
                                                                                                                              :Code ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute"

	payload := strings.NewReader("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessToken: '',
  AttributeName: '',
  Code: ''
});

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=AWSCognitoIdentityProviderService.VerifyUserAttribute');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', AttributeName: '', Code: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","AttributeName":"","Code":""}'
};

try {
  const response = await 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=AWSCognitoIdentityProviderService.VerifyUserAttribute',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessToken": "",\n  "AttributeName": "",\n  "Code": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({AccessToken: '', AttributeName: '', Code: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AccessToken: '', AttributeName: '', Code: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessToken: '',
  AttributeName: '',
  Code: ''
});

req.end(function (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=AWSCognitoIdentityProviderService.VerifyUserAttribute',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AccessToken: '', AttributeName: '', Code: ''}
};

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=AWSCognitoIdentityProviderService.VerifyUserAttribute';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccessToken":"","AttributeName":"","Code":""}'
};

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": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessToken": @"",
                              @"AttributeName": @"",
                              @"Code": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessToken' => '',
    'AttributeName' => '',
    'Code' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "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=AWSCognitoIdentityProviderService.VerifyUserAttribute', [
  'body' => '{
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessToken' => '',
  'AttributeName' => '',
  'Code' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessToken' => '',
  'AttributeName' => '',
  'Code' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute"

payload = {
    "AccessToken": "",
    "AttributeName": "",
    "Code": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute"

payload <- "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AccessToken\": \"\",\n  \"AttributeName\": \"\",\n  \"Code\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute";

    let payload = json!({
        "AccessToken": "",
        "AttributeName": "",
        "Code": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
}'

echo '{
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessToken": "",\n  "AttributeName": "",\n  "Code": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccessToken": "",
  "AttributeName": "",
  "Code": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSCognitoIdentityProviderService.VerifyUserAttribute")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()