Amazon Appflow

POST CreateConnectorProfile

{{baseUrl}}/create-connector-profile

BODY json

{
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/create-connector-profile");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/create-connector-profile" {:content-type :json
                                                                     :form-params {:connectorProfileName ""
                                                                                   :kmsArn ""
                                                                                   :connectorType ""
                                                                                   :connectorLabel ""
                                                                                   :connectionMode ""
                                                                                   :connectorProfileConfig {:connectorProfileProperties ""
                                                                                                            :connectorProfileCredentials ""}
                                                                                   :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/create-connector-profile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/create-connector-profile"),
    Content = new StringContent("{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/create-connector-profile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/create-connector-profile"

	payload := strings.NewReader("{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/create-connector-profile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 251

{
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/create-connector-profile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/create-connector-profile"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/create-connector-profile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/create-connector-profile")
  .header("content-type", "application/json")
  .body("{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorProfileName: '',
  kmsArn: '',
  connectorType: '',
  connectorLabel: '',
  connectionMode: '',
  connectorProfileConfig: {
    connectorProfileProperties: '',
    connectorProfileCredentials: ''
  },
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/create-connector-profile',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileName: '',
    kmsArn: '',
    connectorType: '',
    connectorLabel: '',
    connectionMode: '',
    connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
    clientToken: ''
  }
};

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

const url = '{{baseUrl}}/create-connector-profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","kmsArn":"","connectorType":"","connectorLabel":"","connectionMode":"","connectorProfileConfig":{"connectorProfileProperties":"","connectorProfileCredentials":""},"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/create-connector-profile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorProfileName": "",\n  "kmsArn": "",\n  "connectorType": "",\n  "connectorLabel": "",\n  "connectionMode": "",\n  "connectorProfileConfig": {\n    "connectorProfileProperties": "",\n    "connectorProfileCredentials": ""\n  },\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/create-connector-profile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  connectorProfileName: '',
  kmsArn: '',
  connectorType: '',
  connectorLabel: '',
  connectionMode: '',
  connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/create-connector-profile',
  headers: {'content-type': 'application/json'},
  body: {
    connectorProfileName: '',
    kmsArn: '',
    connectorType: '',
    connectorLabel: '',
    connectionMode: '',
    connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
    clientToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/create-connector-profile');

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

req.type('json');
req.send({
  connectorProfileName: '',
  kmsArn: '',
  connectorType: '',
  connectorLabel: '',
  connectionMode: '',
  connectorProfileConfig: {
    connectorProfileProperties: '',
    connectorProfileCredentials: ''
  },
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/create-connector-profile',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileName: '',
    kmsArn: '',
    connectorType: '',
    connectorLabel: '',
    connectionMode: '',
    connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
    clientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/create-connector-profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","kmsArn":"","connectorType":"","connectorLabel":"","connectionMode":"","connectorProfileConfig":{"connectorProfileProperties":"","connectorProfileCredentials":""},"clientToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorProfileName": @"",
                              @"kmsArn": @"",
                              @"connectorType": @"",
                              @"connectorLabel": @"",
                              @"connectionMode": @"",
                              @"connectorProfileConfig": @{ @"connectorProfileProperties": @"", @"connectorProfileCredentials": @"" },
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/create-connector-profile"]
                                                       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}}/create-connector-profile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/create-connector-profile",
  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([
    'connectorProfileName' => '',
    'kmsArn' => '',
    'connectorType' => '',
    'connectorLabel' => '',
    'connectionMode' => '',
    'connectorProfileConfig' => [
        'connectorProfileProperties' => '',
        'connectorProfileCredentials' => ''
    ],
    'clientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/create-connector-profile', [
  'body' => '{
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/create-connector-profile');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorProfileName' => '',
  'kmsArn' => '',
  'connectorType' => '',
  'connectorLabel' => '',
  'connectionMode' => '',
  'connectorProfileConfig' => [
    'connectorProfileProperties' => '',
    'connectorProfileCredentials' => ''
  ],
  'clientToken' => ''
]));

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

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

append(json_encode([
  'connectorProfileName' => '',
  'kmsArn' => '',
  'connectorType' => '',
  'connectorLabel' => '',
  'connectionMode' => '',
  'connectorProfileConfig' => [
    'connectorProfileProperties' => '',
    'connectorProfileCredentials' => ''
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/create-connector-profile');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/create-connector-profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/create-connector-profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/create-connector-profile", payload, headers)

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

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

import requests

url = "{{baseUrl}}/create-connector-profile"

payload = {
    "connectorProfileName": "",
    "kmsArn": "",
    "connectorType": "",
    "connectorLabel": "",
    "connectionMode": "",
    "connectorProfileConfig": {
        "connectorProfileProperties": "",
        "connectorProfileCredentials": ""
    },
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/create-connector-profile"

payload <- "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/create-connector-profile")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/create-connector-profile') do |req|
  req.body = "{\n  \"connectorProfileName\": \"\",\n  \"kmsArn\": \"\",\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "connectorProfileName": "",
        "kmsArn": "",
        "connectorType": "",
        "connectorLabel": "",
        "connectionMode": "",
        "connectorProfileConfig": json!({
            "connectorProfileProperties": "",
            "connectorProfileCredentials": ""
        }),
        "clientToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/create-connector-profile \
  --header 'content-type: application/json' \
  --data '{
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}'

echo '{
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/create-connector-profile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorProfileName": "",\n  "kmsArn": "",\n  "connectorType": "",\n  "connectorLabel": "",\n  "connectionMode": "",\n  "connectorProfileConfig": {\n    "connectorProfileProperties": "",\n    "connectorProfileCredentials": ""\n  },\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/create-connector-profile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorProfileName": "",
  "kmsArn": "",
  "connectorType": "",
  "connectorLabel": "",
  "connectionMode": "",
  "connectorProfileConfig": [
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  ],
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/create-flow

BODY json

{
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "tags": {},
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/create-flow");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/create-flow" {:content-type :json
                                                        :form-params {:flowName ""
                                                                      :description ""
                                                                      :kmsArn ""
                                                                      :triggerConfig {:triggerType ""
                                                                                      :triggerProperties ""}
                                                                      :sourceFlowConfig {:connectorType ""
                                                                                         :apiVersion ""
                                                                                         :connectorProfileName ""
                                                                                         :sourceConnectorProperties ""
                                                                                         :incrementalPullConfig ""}
                                                                      :destinationFlowConfigList [{:connectorType ""
                                                                                                   :apiVersion ""
                                                                                                   :connectorProfileName ""
                                                                                                   :destinationConnectorProperties ""}]
                                                                      :tasks [{:sourceFields ""
                                                                               :connectorOperator ""
                                                                               :destinationField ""
                                                                               :taskType ""
                                                                               :taskProperties ""}]
                                                                      :tags {}
                                                                      :metadataCatalogConfig {:glueDataCatalog ""}
                                                                      :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/create-flow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/create-flow"),
    Content = new StringContent("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/create-flow");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/create-flow"

	payload := strings.NewReader("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/create-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 750

{
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "tags": {},
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/create-flow")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/create-flow"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/create-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/create-flow")
  .header("content-type", "application/json")
  .body("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  flowName: '',
  description: '',
  kmsArn: '',
  triggerConfig: {
    triggerType: '',
    triggerProperties: ''
  },
  sourceFlowConfig: {
    connectorType: '',
    apiVersion: '',
    connectorProfileName: '',
    sourceConnectorProperties: '',
    incrementalPullConfig: ''
  },
  destinationFlowConfigList: [
    {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      destinationConnectorProperties: ''
    }
  ],
  tasks: [
    {
      sourceFields: '',
      connectorOperator: '',
      destinationField: '',
      taskType: '',
      taskProperties: ''
    }
  ],
  tags: {},
  metadataCatalogConfig: {
    glueDataCatalog: ''
  },
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/create-flow',
  headers: {'content-type': 'application/json'},
  data: {
    flowName: '',
    description: '',
    kmsArn: '',
    triggerConfig: {triggerType: '', triggerProperties: ''},
    sourceFlowConfig: {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      sourceConnectorProperties: '',
      incrementalPullConfig: ''
    },
    destinationFlowConfigList: [
      {
        connectorType: '',
        apiVersion: '',
        connectorProfileName: '',
        destinationConnectorProperties: ''
      }
    ],
    tasks: [
      {
        sourceFields: '',
        connectorOperator: '',
        destinationField: '',
        taskType: '',
        taskProperties: ''
      }
    ],
    tags: {},
    metadataCatalogConfig: {glueDataCatalog: ''},
    clientToken: ''
  }
};

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

const url = '{{baseUrl}}/create-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","description":"","kmsArn":"","triggerConfig":{"triggerType":"","triggerProperties":""},"sourceFlowConfig":{"connectorType":"","apiVersion":"","connectorProfileName":"","sourceConnectorProperties":"","incrementalPullConfig":""},"destinationFlowConfigList":[{"connectorType":"","apiVersion":"","connectorProfileName":"","destinationConnectorProperties":""}],"tasks":[{"sourceFields":"","connectorOperator":"","destinationField":"","taskType":"","taskProperties":""}],"tags":{},"metadataCatalogConfig":{"glueDataCatalog":""},"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/create-flow',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "flowName": "",\n  "description": "",\n  "kmsArn": "",\n  "triggerConfig": {\n    "triggerType": "",\n    "triggerProperties": ""\n  },\n  "sourceFlowConfig": {\n    "connectorType": "",\n    "apiVersion": "",\n    "connectorProfileName": "",\n    "sourceConnectorProperties": "",\n    "incrementalPullConfig": ""\n  },\n  "destinationFlowConfigList": [\n    {\n      "connectorType": "",\n      "apiVersion": "",\n      "connectorProfileName": "",\n      "destinationConnectorProperties": ""\n    }\n  ],\n  "tasks": [\n    {\n      "sourceFields": "",\n      "connectorOperator": "",\n      "destinationField": "",\n      "taskType": "",\n      "taskProperties": ""\n    }\n  ],\n  "tags": {},\n  "metadataCatalogConfig": {\n    "glueDataCatalog": ""\n  },\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/create-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  flowName: '',
  description: '',
  kmsArn: '',
  triggerConfig: {triggerType: '', triggerProperties: ''},
  sourceFlowConfig: {
    connectorType: '',
    apiVersion: '',
    connectorProfileName: '',
    sourceConnectorProperties: '',
    incrementalPullConfig: ''
  },
  destinationFlowConfigList: [
    {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      destinationConnectorProperties: ''
    }
  ],
  tasks: [
    {
      sourceFields: '',
      connectorOperator: '',
      destinationField: '',
      taskType: '',
      taskProperties: ''
    }
  ],
  tags: {},
  metadataCatalogConfig: {glueDataCatalog: ''},
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/create-flow',
  headers: {'content-type': 'application/json'},
  body: {
    flowName: '',
    description: '',
    kmsArn: '',
    triggerConfig: {triggerType: '', triggerProperties: ''},
    sourceFlowConfig: {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      sourceConnectorProperties: '',
      incrementalPullConfig: ''
    },
    destinationFlowConfigList: [
      {
        connectorType: '',
        apiVersion: '',
        connectorProfileName: '',
        destinationConnectorProperties: ''
      }
    ],
    tasks: [
      {
        sourceFields: '',
        connectorOperator: '',
        destinationField: '',
        taskType: '',
        taskProperties: ''
      }
    ],
    tags: {},
    metadataCatalogConfig: {glueDataCatalog: ''},
    clientToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/create-flow');

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

req.type('json');
req.send({
  flowName: '',
  description: '',
  kmsArn: '',
  triggerConfig: {
    triggerType: '',
    triggerProperties: ''
  },
  sourceFlowConfig: {
    connectorType: '',
    apiVersion: '',
    connectorProfileName: '',
    sourceConnectorProperties: '',
    incrementalPullConfig: ''
  },
  destinationFlowConfigList: [
    {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      destinationConnectorProperties: ''
    }
  ],
  tasks: [
    {
      sourceFields: '',
      connectorOperator: '',
      destinationField: '',
      taskType: '',
      taskProperties: ''
    }
  ],
  tags: {},
  metadataCatalogConfig: {
    glueDataCatalog: ''
  },
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/create-flow',
  headers: {'content-type': 'application/json'},
  data: {
    flowName: '',
    description: '',
    kmsArn: '',
    triggerConfig: {triggerType: '', triggerProperties: ''},
    sourceFlowConfig: {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      sourceConnectorProperties: '',
      incrementalPullConfig: ''
    },
    destinationFlowConfigList: [
      {
        connectorType: '',
        apiVersion: '',
        connectorProfileName: '',
        destinationConnectorProperties: ''
      }
    ],
    tasks: [
      {
        sourceFields: '',
        connectorOperator: '',
        destinationField: '',
        taskType: '',
        taskProperties: ''
      }
    ],
    tags: {},
    metadataCatalogConfig: {glueDataCatalog: ''},
    clientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/create-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","description":"","kmsArn":"","triggerConfig":{"triggerType":"","triggerProperties":""},"sourceFlowConfig":{"connectorType":"","apiVersion":"","connectorProfileName":"","sourceConnectorProperties":"","incrementalPullConfig":""},"destinationFlowConfigList":[{"connectorType":"","apiVersion":"","connectorProfileName":"","destinationConnectorProperties":""}],"tasks":[{"sourceFields":"","connectorOperator":"","destinationField":"","taskType":"","taskProperties":""}],"tags":{},"metadataCatalogConfig":{"glueDataCatalog":""},"clientToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"flowName": @"",
                              @"description": @"",
                              @"kmsArn": @"",
                              @"triggerConfig": @{ @"triggerType": @"", @"triggerProperties": @"" },
                              @"sourceFlowConfig": @{ @"connectorType": @"", @"apiVersion": @"", @"connectorProfileName": @"", @"sourceConnectorProperties": @"", @"incrementalPullConfig": @"" },
                              @"destinationFlowConfigList": @[ @{ @"connectorType": @"", @"apiVersion": @"", @"connectorProfileName": @"", @"destinationConnectorProperties": @"" } ],
                              @"tasks": @[ @{ @"sourceFields": @"", @"connectorOperator": @"", @"destinationField": @"", @"taskType": @"", @"taskProperties": @"" } ],
                              @"tags": @{  },
                              @"metadataCatalogConfig": @{ @"glueDataCatalog": @"" },
                              @"clientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/create-flow"]
                                                       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}}/create-flow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/create-flow",
  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([
    'flowName' => '',
    'description' => '',
    'kmsArn' => '',
    'triggerConfig' => [
        'triggerType' => '',
        'triggerProperties' => ''
    ],
    'sourceFlowConfig' => [
        'connectorType' => '',
        'apiVersion' => '',
        'connectorProfileName' => '',
        'sourceConnectorProperties' => '',
        'incrementalPullConfig' => ''
    ],
    'destinationFlowConfigList' => [
        [
                'connectorType' => '',
                'apiVersion' => '',
                'connectorProfileName' => '',
                'destinationConnectorProperties' => ''
        ]
    ],
    'tasks' => [
        [
                'sourceFields' => '',
                'connectorOperator' => '',
                'destinationField' => '',
                'taskType' => '',
                'taskProperties' => ''
        ]
    ],
    'tags' => [
        
    ],
    'metadataCatalogConfig' => [
        'glueDataCatalog' => ''
    ],
    'clientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/create-flow', [
  'body' => '{
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "tags": {},
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'flowName' => '',
  'description' => '',
  'kmsArn' => '',
  'triggerConfig' => [
    'triggerType' => '',
    'triggerProperties' => ''
  ],
  'sourceFlowConfig' => [
    'connectorType' => '',
    'apiVersion' => '',
    'connectorProfileName' => '',
    'sourceConnectorProperties' => '',
    'incrementalPullConfig' => ''
  ],
  'destinationFlowConfigList' => [
    [
        'connectorType' => '',
        'apiVersion' => '',
        'connectorProfileName' => '',
        'destinationConnectorProperties' => ''
    ]
  ],
  'tasks' => [
    [
        'sourceFields' => '',
        'connectorOperator' => '',
        'destinationField' => '',
        'taskType' => '',
        'taskProperties' => ''
    ]
  ],
  'tags' => [
    
  ],
  'metadataCatalogConfig' => [
    'glueDataCatalog' => ''
  ],
  'clientToken' => ''
]));

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

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

append(json_encode([
  'flowName' => '',
  'description' => '',
  'kmsArn' => '',
  'triggerConfig' => [
    'triggerType' => '',
    'triggerProperties' => ''
  ],
  'sourceFlowConfig' => [
    'connectorType' => '',
    'apiVersion' => '',
    'connectorProfileName' => '',
    'sourceConnectorProperties' => '',
    'incrementalPullConfig' => ''
  ],
  'destinationFlowConfigList' => [
    [
        'connectorType' => '',
        'apiVersion' => '',
        'connectorProfileName' => '',
        'destinationConnectorProperties' => ''
    ]
  ],
  'tasks' => [
    [
        'sourceFields' => '',
        'connectorOperator' => '',
        'destinationField' => '',
        'taskType' => '',
        'taskProperties' => ''
    ]
  ],
  'tags' => [
    
  ],
  'metadataCatalogConfig' => [
    'glueDataCatalog' => ''
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/create-flow');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/create-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "tags": {},
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/create-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "tags": {},
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/create-flow"

payload = {
    "flowName": "",
    "description": "",
    "kmsArn": "",
    "triggerConfig": {
        "triggerType": "",
        "triggerProperties": ""
    },
    "sourceFlowConfig": {
        "connectorType": "",
        "apiVersion": "",
        "connectorProfileName": "",
        "sourceConnectorProperties": "",
        "incrementalPullConfig": ""
    },
    "destinationFlowConfigList": [
        {
            "connectorType": "",
            "apiVersion": "",
            "connectorProfileName": "",
            "destinationConnectorProperties": ""
        }
    ],
    "tasks": [
        {
            "sourceFields": "",
            "connectorOperator": "",
            "destinationField": "",
            "taskType": "",
            "taskProperties": ""
        }
    ],
    "tags": {},
    "metadataCatalogConfig": { "glueDataCatalog": "" },
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/create-flow"

payload <- "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/create-flow")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/create-flow') do |req|
  req.body = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"kmsArn\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "flowName": "",
        "description": "",
        "kmsArn": "",
        "triggerConfig": json!({
            "triggerType": "",
            "triggerProperties": ""
        }),
        "sourceFlowConfig": json!({
            "connectorType": "",
            "apiVersion": "",
            "connectorProfileName": "",
            "sourceConnectorProperties": "",
            "incrementalPullConfig": ""
        }),
        "destinationFlowConfigList": (
            json!({
                "connectorType": "",
                "apiVersion": "",
                "connectorProfileName": "",
                "destinationConnectorProperties": ""
            })
        ),
        "tasks": (
            json!({
                "sourceFields": "",
                "connectorOperator": "",
                "destinationField": "",
                "taskType": "",
                "taskProperties": ""
            })
        ),
        "tags": json!({}),
        "metadataCatalogConfig": json!({"glueDataCatalog": ""}),
        "clientToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/create-flow \
  --header 'content-type: application/json' \
  --data '{
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "tags": {},
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}'

echo '{
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "tags": {},
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/create-flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowName": "",\n  "description": "",\n  "kmsArn": "",\n  "triggerConfig": {\n    "triggerType": "",\n    "triggerProperties": ""\n  },\n  "sourceFlowConfig": {\n    "connectorType": "",\n    "apiVersion": "",\n    "connectorProfileName": "",\n    "sourceConnectorProperties": "",\n    "incrementalPullConfig": ""\n  },\n  "destinationFlowConfigList": [\n    {\n      "connectorType": "",\n      "apiVersion": "",\n      "connectorProfileName": "",\n      "destinationConnectorProperties": ""\n    }\n  ],\n  "tasks": [\n    {\n      "sourceFields": "",\n      "connectorOperator": "",\n      "destinationField": "",\n      "taskType": "",\n      "taskProperties": ""\n    }\n  ],\n  "tags": {},\n  "metadataCatalogConfig": {\n    "glueDataCatalog": ""\n  },\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/create-flow

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "flowName": "",
  "description": "",
  "kmsArn": "",
  "triggerConfig": [
    "triggerType": "",
    "triggerProperties": ""
  ],
  "sourceFlowConfig": [
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  ],
  "destinationFlowConfigList": [
    [
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    ]
  ],
  "tasks": [
    [
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    ]
  ],
  "tags": [],
  "metadataCatalogConfig": ["glueDataCatalog": ""],
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/delete-connector-profile

BODY json

{
  "connectorProfileName": "",
  "forceDelete": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/delete-connector-profile");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/delete-connector-profile" {:content-type :json
                                                                     :form-params {:connectorProfileName ""
                                                                                   :forceDelete false}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/delete-connector-profile"

	payload := strings.NewReader("{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}")

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

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

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

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

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

}

POST /baseUrl/delete-connector-profile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "connectorProfileName": "",
  "forceDelete": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/delete-connector-profile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/delete-connector-profile")
  .header("content-type", "application/json")
  .body("{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}")
  .asString();

const data = JSON.stringify({
  connectorProfileName: '',
  forceDelete: false
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/delete-connector-profile',
  headers: {'content-type': 'application/json'},
  data: {connectorProfileName: '', forceDelete: false}
};

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

const url = '{{baseUrl}}/delete-connector-profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","forceDelete":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/delete-connector-profile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorProfileName": "",\n  "forceDelete": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/delete-connector-profile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({connectorProfileName: '', forceDelete: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/delete-connector-profile',
  headers: {'content-type': 'application/json'},
  body: {connectorProfileName: '', forceDelete: false},
  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}}/delete-connector-profile');

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

req.type('json');
req.send({
  connectorProfileName: '',
  forceDelete: false
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/delete-connector-profile',
  headers: {'content-type': 'application/json'},
  data: {connectorProfileName: '', forceDelete: false}
};

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

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

const url = '{{baseUrl}}/delete-connector-profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","forceDelete":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorProfileName": @"",
                              @"forceDelete": @NO };

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

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

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

 "{{baseUrl}}/delete-connector-profile",
  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([
    'connectorProfileName' => '',
    'forceDelete' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/delete-connector-profile', [
  'body' => '{
  "connectorProfileName": "",
  "forceDelete": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/delete-connector-profile');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorProfileName' => '',
  'forceDelete' => null
]));

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

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

append(json_encode([
  'connectorProfileName' => '',
  'forceDelete' => null
]));
$request->setRequestUrl('{{baseUrl}}/delete-connector-profile');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/delete-connector-profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "forceDelete": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/delete-connector-profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "forceDelete": false
}'

import http.client

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

payload = "{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}"

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

conn.request("POST", "/baseUrl/delete-connector-profile", payload, headers)

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

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

import requests

url = "{{baseUrl}}/delete-connector-profile"

payload = {
    "connectorProfileName": "",
    "forceDelete": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/delete-connector-profile"

payload <- "{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/delete-connector-profile")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\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/delete-connector-profile') do |req|
  req.body = "{\n  \"connectorProfileName\": \"\",\n  \"forceDelete\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "connectorProfileName": "",
        "forceDelete": false
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/delete-connector-profile \
  --header 'content-type: application/json' \
  --data '{
  "connectorProfileName": "",
  "forceDelete": false
}'

echo '{
  "connectorProfileName": "",
  "forceDelete": false
}' |  \
  http POST {{baseUrl}}/delete-connector-profile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorProfileName": "",\n  "forceDelete": false\n}' \
  --output-document \
  - {{baseUrl}}/delete-connector-profile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorProfileName": "",
  "forceDelete": false
] as [String : Any]

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

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

{{baseUrl}}/delete-flow

BODY json

{
  "flowName": "",
  "forceDelete": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/delete-flow");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"flowName\": \"\",\n  \"forceDelete\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/delete-flow" {:content-type :json
                                                        :form-params {:flowName ""
                                                                      :forceDelete false}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/delete-flow"

	payload := strings.NewReader("{\n  \"flowName\": \"\",\n  \"forceDelete\": false\n}")

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

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

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

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

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

}

POST /baseUrl/delete-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "flowName": "",
  "forceDelete": false
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/delete-flow")
  .header("content-type", "application/json")
  .body("{\n  \"flowName\": \"\",\n  \"forceDelete\": false\n}")
  .asString();

const data = JSON.stringify({
  flowName: '',
  forceDelete: false
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/delete-flow',
  headers: {'content-type': 'application/json'},
  data: {flowName: '', forceDelete: false}
};

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

const url = '{{baseUrl}}/delete-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","forceDelete":false}'
};

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\",\n  \"forceDelete\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/delete-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({flowName: '', forceDelete: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/delete-flow',
  headers: {'content-type': 'application/json'},
  body: {flowName: '', forceDelete: false},
  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}}/delete-flow');

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

req.type('json');
req.send({
  flowName: '',
  forceDelete: false
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/delete-flow',
  headers: {'content-type': 'application/json'},
  data: {flowName: '', forceDelete: false}
};

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

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

const url = '{{baseUrl}}/delete-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","forceDelete":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"flowName": @"",
                              @"forceDelete": @NO };

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

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

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

 "{{baseUrl}}/delete-flow",
  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([
    'flowName' => '',
    'forceDelete' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/delete-flow', [
  'body' => '{
  "flowName": "",
  "forceDelete": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'flowName' => '',
  'forceDelete' => null
]));

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

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

append(json_encode([
  'flowName' => '',
  'forceDelete' => null
]));
$request->setRequestUrl('{{baseUrl}}/delete-flow');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/delete-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "forceDelete": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/delete-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "forceDelete": false
}'

import http.client

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

payload = "{\n  \"flowName\": \"\",\n  \"forceDelete\": false\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/delete-flow"

payload = {
    "flowName": "",
    "forceDelete": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/delete-flow"

payload <- "{\n  \"flowName\": \"\",\n  \"forceDelete\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/delete-flow")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"flowName\": \"\",\n  \"forceDelete\": false\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/delete-flow') do |req|
  req.body = "{\n  \"flowName\": \"\",\n  \"forceDelete\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "flowName": "",
        "forceDelete": false
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/delete-flow \
  --header 'content-type: application/json' \
  --data '{
  "flowName": "",
  "forceDelete": false
}'

echo '{
  "flowName": "",
  "forceDelete": false
}' |  \
  http POST {{baseUrl}}/delete-flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowName": "",\n  "forceDelete": false\n}' \
  --output-document \
  - {{baseUrl}}/delete-flow

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "flowName": "",
  "forceDelete": false
] as [String : Any]

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

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

{{baseUrl}}/describe-connector

BODY json

{
  "connectorType": "",
  "connectorLabel": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/describe-connector");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/describe-connector" {:content-type :json
                                                               :form-params {:connectorType ""
                                                                             :connectorLabel ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/describe-connector"

	payload := strings.NewReader("{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/describe-connector HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "connectorType": "",
  "connectorLabel": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/describe-connector")
  .header("content-type", "application/json")
  .body("{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorType: '',
  connectorLabel: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connector',
  headers: {'content-type': 'application/json'},
  data: {connectorType: '', connectorLabel: ''}
};

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

const url = '{{baseUrl}}/describe-connector';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorType":"","connectorLabel":""}'
};

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/describe-connector")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({connectorType: '', connectorLabel: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  connectorType: '',
  connectorLabel: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connector',
  headers: {'content-type': 'application/json'},
  data: {connectorType: '', connectorLabel: ''}
};

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

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

const url = '{{baseUrl}}/describe-connector';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorType":"","connectorLabel":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorType": @"",
                              @"connectorLabel": @"" };

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

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

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

 "{{baseUrl}}/describe-connector",
  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([
    'connectorType' => '',
    'connectorLabel' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/describe-connector', [
  'body' => '{
  "connectorType": "",
  "connectorLabel": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'connectorType' => '',
  'connectorLabel' => ''
]));
$request->setRequestUrl('{{baseUrl}}/describe-connector');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/describe-connector' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorType": "",
  "connectorLabel": ""
}'

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

import http.client

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

payload = "{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/describe-connector"

payload = {
    "connectorType": "",
    "connectorLabel": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/describe-connector"

payload <- "{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/describe-connector")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\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/describe-connector') do |req|
  req.body = "{\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "connectorType": "",
        "connectorLabel": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/describe-connector \
  --header 'content-type: application/json' \
  --data '{
  "connectorType": "",
  "connectorLabel": ""
}'

echo '{
  "connectorType": "",
  "connectorLabel": ""
}' |  \
  http POST {{baseUrl}}/describe-connector \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorType": "",\n  "connectorLabel": ""\n}' \
  --output-document \
  - {{baseUrl}}/describe-connector

import Foundation

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

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

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

{{baseUrl}}/describe-connector-entity

BODY json

{
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/describe-connector-entity");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/describe-connector-entity" {:content-type :json
                                                                      :form-params {:connectorEntityName ""
                                                                                    :connectorType ""
                                                                                    :connectorProfileName ""
                                                                                    :apiVersion ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/describe-connector-entity"

	payload := strings.NewReader("{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/describe-connector-entity HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/describe-connector-entity")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/describe-connector-entity")
  .header("content-type", "application/json")
  .body("{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorEntityName: '',
  connectorType: '',
  connectorProfileName: '',
  apiVersion: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connector-entity',
  headers: {'content-type': 'application/json'},
  data: {
    connectorEntityName: '',
    connectorType: '',
    connectorProfileName: '',
    apiVersion: ''
  }
};

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

const url = '{{baseUrl}}/describe-connector-entity';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorEntityName":"","connectorType":"","connectorProfileName":"","apiVersion":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/describe-connector-entity',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorEntityName": "",\n  "connectorType": "",\n  "connectorProfileName": "",\n  "apiVersion": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/describe-connector-entity")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  connectorEntityName: '',
  connectorType: '',
  connectorProfileName: '',
  apiVersion: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connector-entity',
  headers: {'content-type': 'application/json'},
  body: {
    connectorEntityName: '',
    connectorType: '',
    connectorProfileName: '',
    apiVersion: ''
  },
  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}}/describe-connector-entity');

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

req.type('json');
req.send({
  connectorEntityName: '',
  connectorType: '',
  connectorProfileName: '',
  apiVersion: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connector-entity',
  headers: {'content-type': 'application/json'},
  data: {
    connectorEntityName: '',
    connectorType: '',
    connectorProfileName: '',
    apiVersion: ''
  }
};

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

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

const url = '{{baseUrl}}/describe-connector-entity';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorEntityName":"","connectorType":"","connectorProfileName":"","apiVersion":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorEntityName": @"",
                              @"connectorType": @"",
                              @"connectorProfileName": @"",
                              @"apiVersion": @"" };

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

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

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

 "{{baseUrl}}/describe-connector-entity",
  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([
    'connectorEntityName' => '',
    'connectorType' => '',
    'connectorProfileName' => '',
    'apiVersion' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/describe-connector-entity', [
  'body' => '{
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/describe-connector-entity');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorEntityName' => '',
  'connectorType' => '',
  'connectorProfileName' => '',
  'apiVersion' => ''
]));

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

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

append(json_encode([
  'connectorEntityName' => '',
  'connectorType' => '',
  'connectorProfileName' => '',
  'apiVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/describe-connector-entity');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/describe-connector-entity' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/describe-connector-entity' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
}'

import http.client

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

payload = "{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}"

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

conn.request("POST", "/baseUrl/describe-connector-entity", payload, headers)

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

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

import requests

url = "{{baseUrl}}/describe-connector-entity"

payload = {
    "connectorEntityName": "",
    "connectorType": "",
    "connectorProfileName": "",
    "apiVersion": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/describe-connector-entity"

payload <- "{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/describe-connector-entity")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\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/describe-connector-entity') do |req|
  req.body = "{\n  \"connectorEntityName\": \"\",\n  \"connectorType\": \"\",\n  \"connectorProfileName\": \"\",\n  \"apiVersion\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "connectorEntityName": "",
        "connectorType": "",
        "connectorProfileName": "",
        "apiVersion": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/describe-connector-entity \
  --header 'content-type: application/json' \
  --data '{
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
}'

echo '{
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
}' |  \
  http POST {{baseUrl}}/describe-connector-entity \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorEntityName": "",\n  "connectorType": "",\n  "connectorProfileName": "",\n  "apiVersion": ""\n}' \
  --output-document \
  - {{baseUrl}}/describe-connector-entity

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorEntityName": "",
  "connectorType": "",
  "connectorProfileName": "",
  "apiVersion": ""
] as [String : Any]

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

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

{{baseUrl}}/describe-connector-profiles

BODY json

{
  "connectorProfileNames": [],
  "connectorType": "",
  "connectorLabel": "",
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/describe-connector-profiles");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/describe-connector-profiles" {:content-type :json
                                                                        :form-params {:connectorProfileNames []
                                                                                      :connectorType ""
                                                                                      :connectorLabel ""
                                                                                      :maxResults 0
                                                                                      :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/describe-connector-profiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\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}}/describe-connector-profiles"),
    Content = new StringContent("{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\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}}/describe-connector-profiles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/describe-connector-profiles"

	payload := strings.NewReader("{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/describe-connector-profiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "connectorProfileNames": [],
  "connectorType": "",
  "connectorLabel": "",
  "maxResults": 0,
  "nextToken": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/describe-connector-profiles")
  .header("content-type", "application/json")
  .body("{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorProfileNames: [],
  connectorType: '',
  connectorLabel: '',
  maxResults: 0,
  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}}/describe-connector-profiles');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connector-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileNames: [],
    connectorType: '',
    connectorLabel: '',
    maxResults: 0,
    nextToken: ''
  }
};

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

const url = '{{baseUrl}}/describe-connector-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileNames":[],"connectorType":"","connectorLabel":"","maxResults":0,"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}}/describe-connector-profiles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorProfileNames": [],\n  "connectorType": "",\n  "connectorLabel": "",\n  "maxResults": 0,\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  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/describe-connector-profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  connectorProfileNames: [],
  connectorType: '',
  connectorLabel: '',
  maxResults: 0,
  nextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connector-profiles',
  headers: {'content-type': 'application/json'},
  body: {
    connectorProfileNames: [],
    connectorType: '',
    connectorLabel: '',
    maxResults: 0,
    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}}/describe-connector-profiles');

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

req.type('json');
req.send({
  connectorProfileNames: [],
  connectorType: '',
  connectorLabel: '',
  maxResults: 0,
  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}}/describe-connector-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileNames: [],
    connectorType: '',
    connectorLabel: '',
    maxResults: 0,
    nextToken: ''
  }
};

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

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

const url = '{{baseUrl}}/describe-connector-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileNames":[],"connectorType":"","connectorLabel":"","maxResults":0,"nextToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorProfileNames": @[  ],
                              @"connectorType": @"",
                              @"connectorLabel": @"",
                              @"maxResults": @0,
                              @"nextToken": @"" };

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

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

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

 "{{baseUrl}}/describe-connector-profiles",
  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([
    'connectorProfileNames' => [
        
    ],
    'connectorType' => '',
    'connectorLabel' => '',
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/describe-connector-profiles', [
  'body' => '{
  "connectorProfileNames": [],
  "connectorType": "",
  "connectorLabel": "",
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/describe-connector-profiles');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'connectorProfileNames' => [
    
  ],
  'connectorType' => '',
  'connectorLabel' => '',
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/describe-connector-profiles');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/describe-connector-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileNames": [],
  "connectorType": "",
  "connectorLabel": "",
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/describe-connector-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileNames": [],
  "connectorType": "",
  "connectorLabel": "",
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

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

payload = "{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/describe-connector-profiles", payload, headers)

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

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

import requests

url = "{{baseUrl}}/describe-connector-profiles"

payload = {
    "connectorProfileNames": [],
    "connectorType": "",
    "connectorLabel": "",
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/describe-connector-profiles"

payload <- "{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/describe-connector-profiles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\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/describe-connector-profiles') do |req|
  req.body = "{\n  \"connectorProfileNames\": [],\n  \"connectorType\": \"\",\n  \"connectorLabel\": \"\",\n  \"maxResults\": 0,\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}}/describe-connector-profiles";

    let payload = json!({
        "connectorProfileNames": (),
        "connectorType": "",
        "connectorLabel": "",
        "maxResults": 0,
        "nextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/describe-connector-profiles \
  --header 'content-type: application/json' \
  --data '{
  "connectorProfileNames": [],
  "connectorType": "",
  "connectorLabel": "",
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "connectorProfileNames": [],
  "connectorType": "",
  "connectorLabel": "",
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/describe-connector-profiles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorProfileNames": [],\n  "connectorType": "",\n  "connectorLabel": "",\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/describe-connector-profiles

import Foundation

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

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

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

{{baseUrl}}/describe-connectors

BODY json

{
  "connectorTypes": [],
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/describe-connectors");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorTypes\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/describe-connectors" {:content-type :json
                                                                :form-params {:connectorTypes []
                                                                              :maxResults 0
                                                                              :nextToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/describe-connectors"

	payload := strings.NewReader("{\n  \"connectorTypes\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/describe-connectors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "connectorTypes": [],
  "maxResults": 0,
  "nextToken": ""
}

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

client.close();

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

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

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

const data = JSON.stringify({
  connectorTypes: [],
  maxResults: 0,
  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}}/describe-connectors');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

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

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

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({connectorTypes: [], maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-connectors',
  headers: {'content-type': 'application/json'},
  body: {connectorTypes: [], maxResults: 0, 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}}/describe-connectors');

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

req.type('json');
req.send({
  connectorTypes: [],
  maxResults: 0,
  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}}/describe-connectors',
  headers: {'content-type': 'application/json'},
  data: {connectorTypes: [], maxResults: 0, nextToken: ''}
};

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

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

const url = '{{baseUrl}}/describe-connectors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorTypes":[],"maxResults":0,"nextToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorTypes": @[  ],
                              @"maxResults": @0,
                              @"nextToken": @"" };

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

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

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

 "{{baseUrl}}/describe-connectors",
  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([
    'connectorTypes' => [
        
    ],
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/describe-connectors', [
  'body' => '{
  "connectorTypes": [],
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'connectorTypes' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/describe-connectors');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/describe-connectors"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/describe-connectors"

payload <- "{\n  \"connectorTypes\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/describe-connectors")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorTypes\": [],\n  \"maxResults\": 0,\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/describe-connectors') do |req|
  req.body = "{\n  \"connectorTypes\": [],\n  \"maxResults\": 0,\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}}/describe-connectors";

    let payload = json!({
        "connectorTypes": (),
        "maxResults": 0,
        "nextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/describe-connectors \
  --header 'content-type: application/json' \
  --data '{
  "connectorTypes": [],
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "connectorTypes": [],
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/describe-connectors \
  content-type:application/json

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

import Foundation

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

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

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

{{baseUrl}}/describe-flow

BODY json

{
  "flowName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/describe-flow");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/describe-flow" {:content-type :json
                                                          :form-params {:flowName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/describe-flow"

	payload := strings.NewReader("{\n  \"flowName\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/describe-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "flowName": ""
}

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

client.close();

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

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

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

const data = JSON.stringify({
  flowName: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-flow',
  headers: {'content-type': 'application/json'},
  data: {flowName: ''}
};

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

const url = '{{baseUrl}}/describe-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":""}'
};

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/describe-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({flowName: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  flowName: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-flow',
  headers: {'content-type': 'application/json'},
  data: {flowName: ''}
};

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

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

const url = '{{baseUrl}}/describe-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"flowName": @"" };

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

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

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

 "{{baseUrl}}/describe-flow",
  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([
    'flowName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/describe-flow', [
  'body' => '{
  "flowName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'flowName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/describe-flow');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/describe-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": ""
}'

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

import http.client

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

payload = "{\n  \"flowName\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/describe-flow"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/describe-flow"

payload <- "{\n  \"flowName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/describe-flow")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"flowName\": \"\"\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/describe-flow') do |req|
  req.body = "{\n  \"flowName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"flowName": ""});

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/describe-flow \
  --header 'content-type: application/json' \
  --data '{
  "flowName": ""
}'

echo '{
  "flowName": ""
}' |  \
  http POST {{baseUrl}}/describe-flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowName": ""\n}' \
  --output-document \
  - {{baseUrl}}/describe-flow

import Foundation

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

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

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

{{baseUrl}}/describe-flow-execution-records

BODY json

{
  "flowName": "",
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/describe-flow-execution-records");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/describe-flow-execution-records" {:content-type :json
                                                                            :form-params {:flowName ""
                                                                                          :maxResults 0
                                                                                          :nextToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/describe-flow-execution-records"

	payload := strings.NewReader("{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/describe-flow-execution-records HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "flowName": "",
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/describe-flow-execution-records")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/describe-flow-execution-records")
  .header("content-type", "application/json")
  .body("{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  flowName: '',
  maxResults: 0,
  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}}/describe-flow-execution-records');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-flow-execution-records',
  headers: {'content-type': 'application/json'},
  data: {flowName: '', maxResults: 0, nextToken: ''}
};

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

const url = '{{baseUrl}}/describe-flow-execution-records';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","maxResults":0,"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}}/describe-flow-execution-records',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "flowName": "",\n  "maxResults": 0,\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  \"flowName\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/describe-flow-execution-records")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/describe-flow-execution-records',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({flowName: '', maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/describe-flow-execution-records',
  headers: {'content-type': 'application/json'},
  body: {flowName: '', maxResults: 0, 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}}/describe-flow-execution-records');

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

req.type('json');
req.send({
  flowName: '',
  maxResults: 0,
  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}}/describe-flow-execution-records',
  headers: {'content-type': 'application/json'},
  data: {flowName: '', maxResults: 0, nextToken: ''}
};

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

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

const url = '{{baseUrl}}/describe-flow-execution-records';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","maxResults":0,"nextToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"flowName": @"",
                              @"maxResults": @0,
                              @"nextToken": @"" };

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

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

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

 "{{baseUrl}}/describe-flow-execution-records",
  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([
    'flowName' => '',
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/describe-flow-execution-records', [
  'body' => '{
  "flowName": "",
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/describe-flow-execution-records');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'flowName' => '',
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/describe-flow-execution-records');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/describe-flow-execution-records' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/describe-flow-execution-records' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

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

payload = "{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/describe-flow-execution-records", payload, headers)

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

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

import requests

url = "{{baseUrl}}/describe-flow-execution-records"

payload = {
    "flowName": "",
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/describe-flow-execution-records"

payload <- "{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/describe-flow-execution-records")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\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/describe-flow-execution-records') do |req|
  req.body = "{\n  \"flowName\": \"\",\n  \"maxResults\": 0,\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}}/describe-flow-execution-records";

    let payload = json!({
        "flowName": "",
        "maxResults": 0,
        "nextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/describe-flow-execution-records \
  --header 'content-type: application/json' \
  --data '{
  "flowName": "",
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "flowName": "",
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/describe-flow-execution-records \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowName": "",\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/describe-flow-execution-records

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/describe-flow-execution-records")! 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 ListConnectorEntities

{{baseUrl}}/list-connector-entities

BODY json

{
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/list-connector-entities");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/list-connector-entities" {:content-type :json
                                                                    :form-params {:connectorProfileName ""
                                                                                  :connectorType ""
                                                                                  :entitiesPath ""
                                                                                  :apiVersion ""
                                                                                  :maxResults 0
                                                                                  :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/list-connector-entities"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\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}}/list-connector-entities"),
    Content = new StringContent("{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\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}}/list-connector-entities");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/list-connector-entities"

	payload := strings.NewReader("{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/list-connector-entities HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 135

{
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/list-connector-entities")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/list-connector-entities")
  .header("content-type", "application/json")
  .body("{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorProfileName: '',
  connectorType: '',
  entitiesPath: '',
  apiVersion: '',
  maxResults: 0,
  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}}/list-connector-entities');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/list-connector-entities',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileName: '',
    connectorType: '',
    entitiesPath: '',
    apiVersion: '',
    maxResults: 0,
    nextToken: ''
  }
};

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

const url = '{{baseUrl}}/list-connector-entities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","connectorType":"","entitiesPath":"","apiVersion":"","maxResults":0,"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}}/list-connector-entities',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorProfileName": "",\n  "connectorType": "",\n  "entitiesPath": "",\n  "apiVersion": "",\n  "maxResults": 0,\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  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/list-connector-entities")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  connectorProfileName: '',
  connectorType: '',
  entitiesPath: '',
  apiVersion: '',
  maxResults: 0,
  nextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/list-connector-entities',
  headers: {'content-type': 'application/json'},
  body: {
    connectorProfileName: '',
    connectorType: '',
    entitiesPath: '',
    apiVersion: '',
    maxResults: 0,
    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}}/list-connector-entities');

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

req.type('json');
req.send({
  connectorProfileName: '',
  connectorType: '',
  entitiesPath: '',
  apiVersion: '',
  maxResults: 0,
  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}}/list-connector-entities',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileName: '',
    connectorType: '',
    entitiesPath: '',
    apiVersion: '',
    maxResults: 0,
    nextToken: ''
  }
};

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

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

const url = '{{baseUrl}}/list-connector-entities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","connectorType":"","entitiesPath":"","apiVersion":"","maxResults":0,"nextToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorProfileName": @"",
                              @"connectorType": @"",
                              @"entitiesPath": @"",
                              @"apiVersion": @"",
                              @"maxResults": @0,
                              @"nextToken": @"" };

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

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

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

 "{{baseUrl}}/list-connector-entities",
  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([
    'connectorProfileName' => '',
    'connectorType' => '',
    'entitiesPath' => '',
    'apiVersion' => '',
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/list-connector-entities', [
  'body' => '{
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/list-connector-entities');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorProfileName' => '',
  'connectorType' => '',
  'entitiesPath' => '',
  'apiVersion' => '',
  'maxResults' => 0,
  'nextToken' => ''
]));

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

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

append(json_encode([
  'connectorProfileName' => '',
  'connectorType' => '',
  'entitiesPath' => '',
  'apiVersion' => '',
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/list-connector-entities');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/list-connector-entities' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/list-connector-entities' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

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

payload = "{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/list-connector-entities", payload, headers)

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

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

import requests

url = "{{baseUrl}}/list-connector-entities"

payload = {
    "connectorProfileName": "",
    "connectorType": "",
    "entitiesPath": "",
    "apiVersion": "",
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/list-connector-entities"

payload <- "{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/list-connector-entities")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\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/list-connector-entities') do |req|
  req.body = "{\n  \"connectorProfileName\": \"\",\n  \"connectorType\": \"\",\n  \"entitiesPath\": \"\",\n  \"apiVersion\": \"\",\n  \"maxResults\": 0,\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}}/list-connector-entities";

    let payload = json!({
        "connectorProfileName": "",
        "connectorType": "",
        "entitiesPath": "",
        "apiVersion": "",
        "maxResults": 0,
        "nextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/list-connector-entities \
  --header 'content-type: application/json' \
  --data '{
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/list-connector-entities \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorProfileName": "",\n  "connectorType": "",\n  "entitiesPath": "",\n  "apiVersion": "",\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/list-connector-entities

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorProfileName": "",
  "connectorType": "",
  "entitiesPath": "",
  "apiVersion": "",
  "maxResults": 0,
  "nextToken": ""
] as [String : Any]

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

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

{{baseUrl}}/list-connectors

BODY json

{
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/list-connectors");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/list-connectors" {:content-type :json
                                                            :form-params {:maxResults 0
                                                                          :nextToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/list-connectors"

	payload := strings.NewReader("{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/list-connectors HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "maxResults": 0,
  "nextToken": ""
}

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

client.close();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/list-connectors',
  headers: {'content-type': 'application/json'},
  data: {maxResults: 0, nextToken: ''}
};

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

const url = '{{baseUrl}}/list-connectors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"maxResults":0,"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}}/list-connectors',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": 0,\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  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/list-connectors")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  maxResults: 0,
  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}}/list-connectors',
  headers: {'content-type': 'application/json'},
  data: {maxResults: 0, nextToken: ''}
};

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

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

const url = '{{baseUrl}}/list-connectors';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"maxResults":0,"nextToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxResults": @0,
                              @"nextToken": @"" };

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

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

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

 "{{baseUrl}}/list-connectors",
  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([
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/list-connectors', [
  'body' => '{
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/list-connectors');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/list-connectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": 0,
  "nextToken": ""
}'

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

import http.client

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

payload = "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/list-connectors"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/list-connectors"

payload <- "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/list-connectors")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": 0,\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/list-connectors') do |req|
  req.body = "{\n  \"maxResults\": 0,\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}}/list-connectors";

    let payload = json!({
        "maxResults": 0,
        "nextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/list-connectors \
  --header 'content-type: application/json' \
  --data '{
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/list-connectors \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/list-connectors

import Foundation

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

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

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

{{baseUrl}}/list-flows

BODY json

{
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/list-flows");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/list-flows" {:content-type :json
                                                       :form-params {:maxResults 0
                                                                     :nextToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/list-flows"

	payload := strings.NewReader("{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/list-flows HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "maxResults": 0,
  "nextToken": ""
}

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

client.close();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/list-flows',
  headers: {'content-type': 'application/json'},
  data: {maxResults: 0, nextToken: ''}
};

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

const url = '{{baseUrl}}/list-flows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"maxResults":0,"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}}/list-flows',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": 0,\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  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/list-flows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  maxResults: 0,
  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}}/list-flows',
  headers: {'content-type': 'application/json'},
  data: {maxResults: 0, nextToken: ''}
};

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

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

const url = '{{baseUrl}}/list-flows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"maxResults":0,"nextToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxResults": @0,
                              @"nextToken": @"" };

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

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

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

 "{{baseUrl}}/list-flows",
  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([
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/list-flows', [
  'body' => '{
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/list-flows');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/list-flows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": 0,
  "nextToken": ""
}'

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

import http.client

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

payload = "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/list-flows"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/list-flows"

payload <- "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/list-flows")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": 0,\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/list-flows') do |req|
  req.body = "{\n  \"maxResults\": 0,\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}}/list-flows";

    let payload = json!({
        "maxResults": 0,
        "nextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/list-flows \
  --header 'content-type: application/json' \
  --data '{
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/list-flows \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/list-flows

import Foundation

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

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

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

GET ListTagsForResource

{{baseUrl}}/tags/:resourceArn

QUERY PARAMS

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tags/:resourceArn")

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

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

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

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

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

}

GET /baseUrl/tags/:resourceArn HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:resourceArn")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/tags/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

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

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags/: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: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

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

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

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in

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

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tags/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/tags/:resourceArn")

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

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

import requests

url = "{{baseUrl}}/tags/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/tags/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/tags/:resourceArn

http GET {{baseUrl}}/tags/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

POST RegisterConnector

{{baseUrl}}/register-connector

BODY json

{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/register-connector");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/register-connector" {:content-type :json
                                                               :form-params {:connectorLabel ""
                                                                             :description ""
                                                                             :connectorProvisioningType ""
                                                                             :connectorProvisioningConfig {:lambda ""}
                                                                             :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/register-connector"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/register-connector"),
    Content = new StringContent("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/register-connector");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/register-connector"

	payload := strings.NewReader("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/register-connector HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 160

{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/register-connector")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/register-connector"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/register-connector")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/register-connector")
  .header("content-type", "application/json")
  .body("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorLabel: '',
  description: '',
  connectorProvisioningType: '',
  connectorProvisioningConfig: {
    lambda: ''
  },
  clientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/register-connector',
  headers: {'content-type': 'application/json'},
  data: {
    connectorLabel: '',
    description: '',
    connectorProvisioningType: '',
    connectorProvisioningConfig: {lambda: ''},
    clientToken: ''
  }
};

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

const url = '{{baseUrl}}/register-connector';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorLabel":"","description":"","connectorProvisioningType":"","connectorProvisioningConfig":{"lambda":""},"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/register-connector',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorLabel": "",\n  "description": "",\n  "connectorProvisioningType": "",\n  "connectorProvisioningConfig": {\n    "lambda": ""\n  },\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/register-connector")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  connectorLabel: '',
  description: '',
  connectorProvisioningType: '',
  connectorProvisioningConfig: {lambda: ''},
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/register-connector',
  headers: {'content-type': 'application/json'},
  body: {
    connectorLabel: '',
    description: '',
    connectorProvisioningType: '',
    connectorProvisioningConfig: {lambda: ''},
    clientToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/register-connector');

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

req.type('json');
req.send({
  connectorLabel: '',
  description: '',
  connectorProvisioningType: '',
  connectorProvisioningConfig: {
    lambda: ''
  },
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/register-connector',
  headers: {'content-type': 'application/json'},
  data: {
    connectorLabel: '',
    description: '',
    connectorProvisioningType: '',
    connectorProvisioningConfig: {lambda: ''},
    clientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/register-connector';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorLabel":"","description":"","connectorProvisioningType":"","connectorProvisioningConfig":{"lambda":""},"clientToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorLabel": @"",
                              @"description": @"",
                              @"connectorProvisioningType": @"",
                              @"connectorProvisioningConfig": @{ @"lambda": @"" },
                              @"clientToken": @"" };

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

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

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

 "{{baseUrl}}/register-connector",
  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([
    'connectorLabel' => '',
    'description' => '',
    'connectorProvisioningType' => '',
    'connectorProvisioningConfig' => [
        'lambda' => ''
    ],
    'clientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/register-connector', [
  'body' => '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorLabel' => '',
  'description' => '',
  'connectorProvisioningType' => '',
  'connectorProvisioningConfig' => [
    'lambda' => ''
  ],
  'clientToken' => ''
]));

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

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

append(json_encode([
  'connectorLabel' => '',
  'description' => '',
  'connectorProvisioningType' => '',
  'connectorProvisioningConfig' => [
    'lambda' => ''
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/register-connector');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/register-connector' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/register-connector' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/register-connector"

payload = {
    "connectorLabel": "",
    "description": "",
    "connectorProvisioningType": "",
    "connectorProvisioningConfig": { "lambda": "" },
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/register-connector"

payload <- "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/register-connector")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/register-connector') do |req|
  req.body = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningType\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "connectorLabel": "",
        "description": "",
        "connectorProvisioningType": "",
        "connectorProvisioningConfig": json!({"lambda": ""}),
        "clientToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/register-connector \
  --header 'content-type: application/json' \
  --data '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}'

echo '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/register-connector \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorLabel": "",\n  "description": "",\n  "connectorProvisioningType": "",\n  "connectorProvisioningConfig": {\n    "lambda": ""\n  },\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/register-connector

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningType": "",
  "connectorProvisioningConfig": ["lambda": ""],
  "clientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/start-flow

BODY json

{
  "flowName": "",
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/start-flow");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/start-flow" {:content-type :json
                                                       :form-params {:flowName ""
                                                                     :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/start-flow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/start-flow"),
    Content = new StringContent("{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/start-flow");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/start-flow"

	payload := strings.NewReader("{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/start-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "flowName": "",
  "clientToken": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/start-flow"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/start-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

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

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

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/start-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({flowName: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/start-flow',
  headers: {'content-type': 'application/json'},
  body: {flowName: '', clientToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/start-flow');

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

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

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

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

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

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

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

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

const url = '{{baseUrl}}/start-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"flowName": @"",
                              @"clientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/start-flow"]
                                                       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}}/start-flow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/start-flow",
  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([
    'flowName' => '',
    'clientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/start-flow', [
  'body' => '{
  "flowName": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/start-flow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'flowName' => '',
  'clientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'flowName' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/start-flow');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/start-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/start-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "clientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/start-flow", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/start-flow"

payload = {
    "flowName": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/start-flow"

payload <- "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/start-flow")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/start-flow') do |req|
  req.body = "{\n  \"flowName\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/start-flow";

    let payload = json!({
        "flowName": "",
        "clientToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/start-flow \
  --header 'content-type: application/json' \
  --data '{
  "flowName": "",
  "clientToken": ""
}'

echo '{
  "flowName": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/start-flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowName": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/start-flow

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "flowName": "",
  "clientToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/start-flow")! 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 StopFlow

{{baseUrl}}/stop-flow

BODY json

{
  "flowName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stop-flow");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"flowName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/stop-flow" {:content-type :json
                                                      :form-params {:flowName ""}})

require "http/client"

url = "{{baseUrl}}/stop-flow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"flowName\": \"\"\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}}/stop-flow"),
    Content = new StringContent("{\n  \"flowName\": \"\"\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}}/stop-flow");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"flowName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/stop-flow"

	payload := strings.NewReader("{\n  \"flowName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/stop-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "flowName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stop-flow")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"flowName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/stop-flow"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"flowName\": \"\"\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  \"flowName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/stop-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/stop-flow")
  .header("content-type", "application/json")
  .body("{\n  \"flowName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  flowName: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/stop-flow');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/stop-flow',
  headers: {'content-type': 'application/json'},
  data: {flowName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/stop-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/stop-flow',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "flowName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/stop-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/stop-flow',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({flowName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/stop-flow',
  headers: {'content-type': 'application/json'},
  body: {flowName: ''},
  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}}/stop-flow');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  flowName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/stop-flow',
  headers: {'content-type': 'application/json'},
  data: {flowName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/stop-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"flowName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stop-flow"]
                                                       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}}/stop-flow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"flowName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/stop-flow",
  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([
    'flowName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/stop-flow', [
  'body' => '{
  "flowName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/stop-flow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'flowName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'flowName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/stop-flow');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stop-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stop-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"flowName\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/stop-flow", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/stop-flow"

payload = { "flowName": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/stop-flow"

payload <- "{\n  \"flowName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/stop-flow")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"flowName\": \"\"\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/stop-flow') do |req|
  req.body = "{\n  \"flowName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/stop-flow";

    let payload = json!({"flowName": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/stop-flow \
  --header 'content-type: application/json' \
  --data '{
  "flowName": ""
}'

echo '{
  "flowName": ""
}' |  \
  http POST {{baseUrl}}/stop-flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowName": ""\n}' \
  --output-document \
  - {{baseUrl}}/stop-flow

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["flowName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stop-flow")! 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}}/tags/:resourceArn

QUERY PARAMS

resourceArn

BODY json

{
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tags/:resourceArn" {:content-type :json
                                                              :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\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}}/tags/:resourceArn"),
    Content = new StringContent("{\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}}/tags/:resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	payload := strings.NewReader("{\n  \"tags\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/tags/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tags/:resourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\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  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tags/:resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  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}}/tags/:resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/tags/:resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\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  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  body: {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}}/tags/:resourceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  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}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       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}}/tags/:resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  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([
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/tags/:resourceArn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/tags/:resourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

payload = { "tags": {} }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

payload <- "{\n  \"tags\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"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/tags/:resourceArn') do |req|
  req.body = "{\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}}/tags/:resourceArn";

    let payload = json!({"tags": json!({})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/tags/:resourceArn \
  --header 'content-type: application/json' \
  --data '{
  "tags": {}
}'

echo '{
  "tags": {}
}' |  \
  http POST {{baseUrl}}/tags/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tags": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! 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 UnregisterConnector

{{baseUrl}}/unregister-connector

BODY json

{
  "connectorLabel": "",
  "forceDelete": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/unregister-connector");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/unregister-connector" {:content-type :json
                                                                 :form-params {:connectorLabel ""
                                                                               :forceDelete false}})

require "http/client"

url = "{{baseUrl}}/unregister-connector"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\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}}/unregister-connector"),
    Content = new StringContent("{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\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}}/unregister-connector");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/unregister-connector"

	payload := strings.NewReader("{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/unregister-connector HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "connectorLabel": "",
  "forceDelete": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/unregister-connector")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/unregister-connector"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\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  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/unregister-connector")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/unregister-connector")
  .header("content-type", "application/json")
  .body("{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}")
  .asString();

const data = JSON.stringify({
  connectorLabel: '',
  forceDelete: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/unregister-connector');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/unregister-connector',
  headers: {'content-type': 'application/json'},
  data: {connectorLabel: '', forceDelete: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/unregister-connector';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorLabel":"","forceDelete":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/unregister-connector',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorLabel": "",\n  "forceDelete": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/unregister-connector")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/unregister-connector',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({connectorLabel: '', forceDelete: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/unregister-connector',
  headers: {'content-type': 'application/json'},
  body: {connectorLabel: '', forceDelete: false},
  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}}/unregister-connector');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  connectorLabel: '',
  forceDelete: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/unregister-connector',
  headers: {'content-type': 'application/json'},
  data: {connectorLabel: '', forceDelete: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/unregister-connector';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorLabel":"","forceDelete":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorLabel": @"",
                              @"forceDelete": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/unregister-connector"]
                                                       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}}/unregister-connector" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/unregister-connector",
  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([
    'connectorLabel' => '',
    'forceDelete' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/unregister-connector', [
  'body' => '{
  "connectorLabel": "",
  "forceDelete": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/unregister-connector');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorLabel' => '',
  'forceDelete' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'connectorLabel' => '',
  'forceDelete' => null
]));
$request->setRequestUrl('{{baseUrl}}/unregister-connector');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/unregister-connector' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorLabel": "",
  "forceDelete": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/unregister-connector' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorLabel": "",
  "forceDelete": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/unregister-connector", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/unregister-connector"

payload = {
    "connectorLabel": "",
    "forceDelete": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/unregister-connector"

payload <- "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/unregister-connector")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\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/unregister-connector') do |req|
  req.body = "{\n  \"connectorLabel\": \"\",\n  \"forceDelete\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/unregister-connector";

    let payload = json!({
        "connectorLabel": "",
        "forceDelete": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/unregister-connector \
  --header 'content-type: application/json' \
  --data '{
  "connectorLabel": "",
  "forceDelete": false
}'

echo '{
  "connectorLabel": "",
  "forceDelete": false
}' |  \
  http POST {{baseUrl}}/unregister-connector \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorLabel": "",\n  "forceDelete": false\n}' \
  --output-document \
  - {{baseUrl}}/unregister-connector

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorLabel": "",
  "forceDelete": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/unregister-connector")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE UntagResource

{{baseUrl}}/tags/:resourceArn#tagKeys

QUERY PARAMS

tagKeys

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tags/:resourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/tags/:resourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn?tagKeys=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  qs: {tagKeys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags/:resourceArn#tagKeys');

req.query({
  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: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tags/:resourceArn?tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn#tagKeys"

queryString <- list(tagKeys = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/tags/:resourceArn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn#tagKeys";

    let querystring = [
        ("tagKeys", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

http DELETE '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateConnectorProfile

{{baseUrl}}/update-connector-profile

BODY json

{
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/update-connector-profile");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/update-connector-profile" {:content-type :json
                                                                     :form-params {:connectorProfileName ""
                                                                                   :connectionMode ""
                                                                                   :connectorProfileConfig {:connectorProfileProperties ""
                                                                                                            :connectorProfileCredentials ""}
                                                                                   :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/update-connector-profile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/update-connector-profile"),
    Content = new StringContent("{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/update-connector-profile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/update-connector-profile"

	payload := strings.NewReader("{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/update-connector-profile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 188

{
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/update-connector-profile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/update-connector-profile"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/update-connector-profile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/update-connector-profile")
  .header("content-type", "application/json")
  .body("{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorProfileName: '',
  connectionMode: '',
  connectorProfileConfig: {
    connectorProfileProperties: '',
    connectorProfileCredentials: ''
  },
  clientToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/update-connector-profile');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-connector-profile',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileName: '',
    connectionMode: '',
    connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/update-connector-profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","connectionMode":"","connectorProfileConfig":{"connectorProfileProperties":"","connectorProfileCredentials":""},"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/update-connector-profile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorProfileName": "",\n  "connectionMode": "",\n  "connectorProfileConfig": {\n    "connectorProfileProperties": "",\n    "connectorProfileCredentials": ""\n  },\n  "clientToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/update-connector-profile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/update-connector-profile',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  connectorProfileName: '',
  connectionMode: '',
  connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-connector-profile',
  headers: {'content-type': 'application/json'},
  body: {
    connectorProfileName: '',
    connectionMode: '',
    connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
    clientToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/update-connector-profile');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  connectorProfileName: '',
  connectionMode: '',
  connectorProfileConfig: {
    connectorProfileProperties: '',
    connectorProfileCredentials: ''
  },
  clientToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-connector-profile',
  headers: {'content-type': 'application/json'},
  data: {
    connectorProfileName: '',
    connectionMode: '',
    connectorProfileConfig: {connectorProfileProperties: '', connectorProfileCredentials: ''},
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/update-connector-profile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorProfileName":"","connectionMode":"","connectorProfileConfig":{"connectorProfileProperties":"","connectorProfileCredentials":""},"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorProfileName": @"",
                              @"connectionMode": @"",
                              @"connectorProfileConfig": @{ @"connectorProfileProperties": @"", @"connectorProfileCredentials": @"" },
                              @"clientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/update-connector-profile"]
                                                       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}}/update-connector-profile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/update-connector-profile",
  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([
    'connectorProfileName' => '',
    'connectionMode' => '',
    'connectorProfileConfig' => [
        'connectorProfileProperties' => '',
        'connectorProfileCredentials' => ''
    ],
    'clientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/update-connector-profile', [
  'body' => '{
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/update-connector-profile');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorProfileName' => '',
  'connectionMode' => '',
  'connectorProfileConfig' => [
    'connectorProfileProperties' => '',
    'connectorProfileCredentials' => ''
  ],
  'clientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'connectorProfileName' => '',
  'connectionMode' => '',
  'connectorProfileConfig' => [
    'connectorProfileProperties' => '',
    'connectorProfileCredentials' => ''
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/update-connector-profile');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/update-connector-profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/update-connector-profile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/update-connector-profile", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/update-connector-profile"

payload = {
    "connectorProfileName": "",
    "connectionMode": "",
    "connectorProfileConfig": {
        "connectorProfileProperties": "",
        "connectorProfileCredentials": ""
    },
    "clientToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/update-connector-profile"

payload <- "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/update-connector-profile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/update-connector-profile') do |req|
  req.body = "{\n  \"connectorProfileName\": \"\",\n  \"connectionMode\": \"\",\n  \"connectorProfileConfig\": {\n    \"connectorProfileProperties\": \"\",\n    \"connectorProfileCredentials\": \"\"\n  },\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/update-connector-profile";

    let payload = json!({
        "connectorProfileName": "",
        "connectionMode": "",
        "connectorProfileConfig": json!({
            "connectorProfileProperties": "",
            "connectorProfileCredentials": ""
        }),
        "clientToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/update-connector-profile \
  --header 'content-type: application/json' \
  --data '{
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}'

echo '{
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": {
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  },
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/update-connector-profile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorProfileName": "",\n  "connectionMode": "",\n  "connectorProfileConfig": {\n    "connectorProfileProperties": "",\n    "connectorProfileCredentials": ""\n  },\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/update-connector-profile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorProfileName": "",
  "connectionMode": "",
  "connectorProfileConfig": [
    "connectorProfileProperties": "",
    "connectorProfileCredentials": ""
  ],
  "clientToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/update-connector-profile")! 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 UpdateConnectorRegistration

{{baseUrl}}/update-connector-registration

BODY json

{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/update-connector-registration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/update-connector-registration" {:content-type :json
                                                                          :form-params {:connectorLabel ""
                                                                                        :description ""
                                                                                        :connectorProvisioningConfig {:lambda ""}
                                                                                        :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/update-connector-registration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/update-connector-registration"),
    Content = new StringContent("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/update-connector-registration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/update-connector-registration"

	payload := strings.NewReader("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/update-connector-registration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 125

{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/update-connector-registration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/update-connector-registration"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/update-connector-registration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/update-connector-registration")
  .header("content-type", "application/json")
  .body("{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectorLabel: '',
  description: '',
  connectorProvisioningConfig: {
    lambda: ''
  },
  clientToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/update-connector-registration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-connector-registration',
  headers: {'content-type': 'application/json'},
  data: {
    connectorLabel: '',
    description: '',
    connectorProvisioningConfig: {lambda: ''},
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/update-connector-registration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorLabel":"","description":"","connectorProvisioningConfig":{"lambda":""},"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/update-connector-registration',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectorLabel": "",\n  "description": "",\n  "connectorProvisioningConfig": {\n    "lambda": ""\n  },\n  "clientToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/update-connector-registration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/update-connector-registration',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  connectorLabel: '',
  description: '',
  connectorProvisioningConfig: {lambda: ''},
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-connector-registration',
  headers: {'content-type': 'application/json'},
  body: {
    connectorLabel: '',
    description: '',
    connectorProvisioningConfig: {lambda: ''},
    clientToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/update-connector-registration');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  connectorLabel: '',
  description: '',
  connectorProvisioningConfig: {
    lambda: ''
  },
  clientToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-connector-registration',
  headers: {'content-type': 'application/json'},
  data: {
    connectorLabel: '',
    description: '',
    connectorProvisioningConfig: {lambda: ''},
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/update-connector-registration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"connectorLabel":"","description":"","connectorProvisioningConfig":{"lambda":""},"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectorLabel": @"",
                              @"description": @"",
                              @"connectorProvisioningConfig": @{ @"lambda": @"" },
                              @"clientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/update-connector-registration"]
                                                       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}}/update-connector-registration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/update-connector-registration",
  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([
    'connectorLabel' => '',
    'description' => '',
    'connectorProvisioningConfig' => [
        'lambda' => ''
    ],
    'clientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/update-connector-registration', [
  'body' => '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/update-connector-registration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectorLabel' => '',
  'description' => '',
  'connectorProvisioningConfig' => [
    'lambda' => ''
  ],
  'clientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'connectorLabel' => '',
  'description' => '',
  'connectorProvisioningConfig' => [
    'lambda' => ''
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/update-connector-registration');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/update-connector-registration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/update-connector-registration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/update-connector-registration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/update-connector-registration"

payload = {
    "connectorLabel": "",
    "description": "",
    "connectorProvisioningConfig": { "lambda": "" },
    "clientToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/update-connector-registration"

payload <- "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/update-connector-registration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/update-connector-registration') do |req|
  req.body = "{\n  \"connectorLabel\": \"\",\n  \"description\": \"\",\n  \"connectorProvisioningConfig\": {\n    \"lambda\": \"\"\n  },\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/update-connector-registration";

    let payload = json!({
        "connectorLabel": "",
        "description": "",
        "connectorProvisioningConfig": json!({"lambda": ""}),
        "clientToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/update-connector-registration \
  --header 'content-type: application/json' \
  --data '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}'

echo '{
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": {
    "lambda": ""
  },
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/update-connector-registration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectorLabel": "",\n  "description": "",\n  "connectorProvisioningConfig": {\n    "lambda": ""\n  },\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/update-connector-registration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "connectorLabel": "",
  "description": "",
  "connectorProvisioningConfig": ["lambda": ""],
  "clientToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/update-connector-registration")! 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 UpdateFlow

{{baseUrl}}/update-flow

BODY json

{
  "flowName": "",
  "description": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/update-flow");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/update-flow" {:content-type :json
                                                        :form-params {:flowName ""
                                                                      :description ""
                                                                      :triggerConfig {:triggerType ""
                                                                                      :triggerProperties ""}
                                                                      :sourceFlowConfig {:connectorType ""
                                                                                         :apiVersion ""
                                                                                         :connectorProfileName ""
                                                                                         :sourceConnectorProperties ""
                                                                                         :incrementalPullConfig ""}
                                                                      :destinationFlowConfigList [{:connectorType ""
                                                                                                   :apiVersion ""
                                                                                                   :connectorProfileName ""
                                                                                                   :destinationConnectorProperties ""}]
                                                                      :tasks [{:sourceFields ""
                                                                               :connectorOperator ""
                                                                               :destinationField ""
                                                                               :taskType ""
                                                                               :taskProperties ""}]
                                                                      :metadataCatalogConfig {:glueDataCatalog ""}
                                                                      :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/update-flow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/update-flow"),
    Content = new StringContent("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/update-flow");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/update-flow"

	payload := strings.NewReader("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/update-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 720

{
  "flowName": "",
  "description": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/update-flow")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/update-flow"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/update-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/update-flow")
  .header("content-type", "application/json")
  .body("{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  flowName: '',
  description: '',
  triggerConfig: {
    triggerType: '',
    triggerProperties: ''
  },
  sourceFlowConfig: {
    connectorType: '',
    apiVersion: '',
    connectorProfileName: '',
    sourceConnectorProperties: '',
    incrementalPullConfig: ''
  },
  destinationFlowConfigList: [
    {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      destinationConnectorProperties: ''
    }
  ],
  tasks: [
    {
      sourceFields: '',
      connectorOperator: '',
      destinationField: '',
      taskType: '',
      taskProperties: ''
    }
  ],
  metadataCatalogConfig: {
    glueDataCatalog: ''
  },
  clientToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/update-flow');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-flow',
  headers: {'content-type': 'application/json'},
  data: {
    flowName: '',
    description: '',
    triggerConfig: {triggerType: '', triggerProperties: ''},
    sourceFlowConfig: {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      sourceConnectorProperties: '',
      incrementalPullConfig: ''
    },
    destinationFlowConfigList: [
      {
        connectorType: '',
        apiVersion: '',
        connectorProfileName: '',
        destinationConnectorProperties: ''
      }
    ],
    tasks: [
      {
        sourceFields: '',
        connectorOperator: '',
        destinationField: '',
        taskType: '',
        taskProperties: ''
      }
    ],
    metadataCatalogConfig: {glueDataCatalog: ''},
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/update-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","description":"","triggerConfig":{"triggerType":"","triggerProperties":""},"sourceFlowConfig":{"connectorType":"","apiVersion":"","connectorProfileName":"","sourceConnectorProperties":"","incrementalPullConfig":""},"destinationFlowConfigList":[{"connectorType":"","apiVersion":"","connectorProfileName":"","destinationConnectorProperties":""}],"tasks":[{"sourceFields":"","connectorOperator":"","destinationField":"","taskType":"","taskProperties":""}],"metadataCatalogConfig":{"glueDataCatalog":""},"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/update-flow',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "flowName": "",\n  "description": "",\n  "triggerConfig": {\n    "triggerType": "",\n    "triggerProperties": ""\n  },\n  "sourceFlowConfig": {\n    "connectorType": "",\n    "apiVersion": "",\n    "connectorProfileName": "",\n    "sourceConnectorProperties": "",\n    "incrementalPullConfig": ""\n  },\n  "destinationFlowConfigList": [\n    {\n      "connectorType": "",\n      "apiVersion": "",\n      "connectorProfileName": "",\n      "destinationConnectorProperties": ""\n    }\n  ],\n  "tasks": [\n    {\n      "sourceFields": "",\n      "connectorOperator": "",\n      "destinationField": "",\n      "taskType": "",\n      "taskProperties": ""\n    }\n  ],\n  "metadataCatalogConfig": {\n    "glueDataCatalog": ""\n  },\n  "clientToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/update-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/update-flow',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  flowName: '',
  description: '',
  triggerConfig: {triggerType: '', triggerProperties: ''},
  sourceFlowConfig: {
    connectorType: '',
    apiVersion: '',
    connectorProfileName: '',
    sourceConnectorProperties: '',
    incrementalPullConfig: ''
  },
  destinationFlowConfigList: [
    {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      destinationConnectorProperties: ''
    }
  ],
  tasks: [
    {
      sourceFields: '',
      connectorOperator: '',
      destinationField: '',
      taskType: '',
      taskProperties: ''
    }
  ],
  metadataCatalogConfig: {glueDataCatalog: ''},
  clientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-flow',
  headers: {'content-type': 'application/json'},
  body: {
    flowName: '',
    description: '',
    triggerConfig: {triggerType: '', triggerProperties: ''},
    sourceFlowConfig: {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      sourceConnectorProperties: '',
      incrementalPullConfig: ''
    },
    destinationFlowConfigList: [
      {
        connectorType: '',
        apiVersion: '',
        connectorProfileName: '',
        destinationConnectorProperties: ''
      }
    ],
    tasks: [
      {
        sourceFields: '',
        connectorOperator: '',
        destinationField: '',
        taskType: '',
        taskProperties: ''
      }
    ],
    metadataCatalogConfig: {glueDataCatalog: ''},
    clientToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/update-flow');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  flowName: '',
  description: '',
  triggerConfig: {
    triggerType: '',
    triggerProperties: ''
  },
  sourceFlowConfig: {
    connectorType: '',
    apiVersion: '',
    connectorProfileName: '',
    sourceConnectorProperties: '',
    incrementalPullConfig: ''
  },
  destinationFlowConfigList: [
    {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      destinationConnectorProperties: ''
    }
  ],
  tasks: [
    {
      sourceFields: '',
      connectorOperator: '',
      destinationField: '',
      taskType: '',
      taskProperties: ''
    }
  ],
  metadataCatalogConfig: {
    glueDataCatalog: ''
  },
  clientToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/update-flow',
  headers: {'content-type': 'application/json'},
  data: {
    flowName: '',
    description: '',
    triggerConfig: {triggerType: '', triggerProperties: ''},
    sourceFlowConfig: {
      connectorType: '',
      apiVersion: '',
      connectorProfileName: '',
      sourceConnectorProperties: '',
      incrementalPullConfig: ''
    },
    destinationFlowConfigList: [
      {
        connectorType: '',
        apiVersion: '',
        connectorProfileName: '',
        destinationConnectorProperties: ''
      }
    ],
    tasks: [
      {
        sourceFields: '',
        connectorOperator: '',
        destinationField: '',
        taskType: '',
        taskProperties: ''
      }
    ],
    metadataCatalogConfig: {glueDataCatalog: ''},
    clientToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/update-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flowName":"","description":"","triggerConfig":{"triggerType":"","triggerProperties":""},"sourceFlowConfig":{"connectorType":"","apiVersion":"","connectorProfileName":"","sourceConnectorProperties":"","incrementalPullConfig":""},"destinationFlowConfigList":[{"connectorType":"","apiVersion":"","connectorProfileName":"","destinationConnectorProperties":""}],"tasks":[{"sourceFields":"","connectorOperator":"","destinationField":"","taskType":"","taskProperties":""}],"metadataCatalogConfig":{"glueDataCatalog":""},"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"flowName": @"",
                              @"description": @"",
                              @"triggerConfig": @{ @"triggerType": @"", @"triggerProperties": @"" },
                              @"sourceFlowConfig": @{ @"connectorType": @"", @"apiVersion": @"", @"connectorProfileName": @"", @"sourceConnectorProperties": @"", @"incrementalPullConfig": @"" },
                              @"destinationFlowConfigList": @[ @{ @"connectorType": @"", @"apiVersion": @"", @"connectorProfileName": @"", @"destinationConnectorProperties": @"" } ],
                              @"tasks": @[ @{ @"sourceFields": @"", @"connectorOperator": @"", @"destinationField": @"", @"taskType": @"", @"taskProperties": @"" } ],
                              @"metadataCatalogConfig": @{ @"glueDataCatalog": @"" },
                              @"clientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/update-flow"]
                                                       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}}/update-flow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/update-flow",
  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([
    'flowName' => '',
    'description' => '',
    'triggerConfig' => [
        'triggerType' => '',
        'triggerProperties' => ''
    ],
    'sourceFlowConfig' => [
        'connectorType' => '',
        'apiVersion' => '',
        'connectorProfileName' => '',
        'sourceConnectorProperties' => '',
        'incrementalPullConfig' => ''
    ],
    'destinationFlowConfigList' => [
        [
                'connectorType' => '',
                'apiVersion' => '',
                'connectorProfileName' => '',
                'destinationConnectorProperties' => ''
        ]
    ],
    'tasks' => [
        [
                'sourceFields' => '',
                'connectorOperator' => '',
                'destinationField' => '',
                'taskType' => '',
                'taskProperties' => ''
        ]
    ],
    'metadataCatalogConfig' => [
        'glueDataCatalog' => ''
    ],
    'clientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/update-flow', [
  'body' => '{
  "flowName": "",
  "description": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/update-flow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'flowName' => '',
  'description' => '',
  'triggerConfig' => [
    'triggerType' => '',
    'triggerProperties' => ''
  ],
  'sourceFlowConfig' => [
    'connectorType' => '',
    'apiVersion' => '',
    'connectorProfileName' => '',
    'sourceConnectorProperties' => '',
    'incrementalPullConfig' => ''
  ],
  'destinationFlowConfigList' => [
    [
        'connectorType' => '',
        'apiVersion' => '',
        'connectorProfileName' => '',
        'destinationConnectorProperties' => ''
    ]
  ],
  'tasks' => [
    [
        'sourceFields' => '',
        'connectorOperator' => '',
        'destinationField' => '',
        'taskType' => '',
        'taskProperties' => ''
    ]
  ],
  'metadataCatalogConfig' => [
    'glueDataCatalog' => ''
  ],
  'clientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'flowName' => '',
  'description' => '',
  'triggerConfig' => [
    'triggerType' => '',
    'triggerProperties' => ''
  ],
  'sourceFlowConfig' => [
    'connectorType' => '',
    'apiVersion' => '',
    'connectorProfileName' => '',
    'sourceConnectorProperties' => '',
    'incrementalPullConfig' => ''
  ],
  'destinationFlowConfigList' => [
    [
        'connectorType' => '',
        'apiVersion' => '',
        'connectorProfileName' => '',
        'destinationConnectorProperties' => ''
    ]
  ],
  'tasks' => [
    [
        'sourceFields' => '',
        'connectorOperator' => '',
        'destinationField' => '',
        'taskType' => '',
        'taskProperties' => ''
    ]
  ],
  'metadataCatalogConfig' => [
    'glueDataCatalog' => ''
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/update-flow');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/update-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "description": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/update-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flowName": "",
  "description": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/update-flow", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/update-flow"

payload = {
    "flowName": "",
    "description": "",
    "triggerConfig": {
        "triggerType": "",
        "triggerProperties": ""
    },
    "sourceFlowConfig": {
        "connectorType": "",
        "apiVersion": "",
        "connectorProfileName": "",
        "sourceConnectorProperties": "",
        "incrementalPullConfig": ""
    },
    "destinationFlowConfigList": [
        {
            "connectorType": "",
            "apiVersion": "",
            "connectorProfileName": "",
            "destinationConnectorProperties": ""
        }
    ],
    "tasks": [
        {
            "sourceFields": "",
            "connectorOperator": "",
            "destinationField": "",
            "taskType": "",
            "taskProperties": ""
        }
    ],
    "metadataCatalogConfig": { "glueDataCatalog": "" },
    "clientToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/update-flow"

payload <- "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/update-flow")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/update-flow') do |req|
  req.body = "{\n  \"flowName\": \"\",\n  \"description\": \"\",\n  \"triggerConfig\": {\n    \"triggerType\": \"\",\n    \"triggerProperties\": \"\"\n  },\n  \"sourceFlowConfig\": {\n    \"connectorType\": \"\",\n    \"apiVersion\": \"\",\n    \"connectorProfileName\": \"\",\n    \"sourceConnectorProperties\": \"\",\n    \"incrementalPullConfig\": \"\"\n  },\n  \"destinationFlowConfigList\": [\n    {\n      \"connectorType\": \"\",\n      \"apiVersion\": \"\",\n      \"connectorProfileName\": \"\",\n      \"destinationConnectorProperties\": \"\"\n    }\n  ],\n  \"tasks\": [\n    {\n      \"sourceFields\": \"\",\n      \"connectorOperator\": \"\",\n      \"destinationField\": \"\",\n      \"taskType\": \"\",\n      \"taskProperties\": \"\"\n    }\n  ],\n  \"metadataCatalogConfig\": {\n    \"glueDataCatalog\": \"\"\n  },\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/update-flow";

    let payload = json!({
        "flowName": "",
        "description": "",
        "triggerConfig": json!({
            "triggerType": "",
            "triggerProperties": ""
        }),
        "sourceFlowConfig": json!({
            "connectorType": "",
            "apiVersion": "",
            "connectorProfileName": "",
            "sourceConnectorProperties": "",
            "incrementalPullConfig": ""
        }),
        "destinationFlowConfigList": (
            json!({
                "connectorType": "",
                "apiVersion": "",
                "connectorProfileName": "",
                "destinationConnectorProperties": ""
            })
        ),
        "tasks": (
            json!({
                "sourceFields": "",
                "connectorOperator": "",
                "destinationField": "",
                "taskType": "",
                "taskProperties": ""
            })
        ),
        "metadataCatalogConfig": json!({"glueDataCatalog": ""}),
        "clientToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/update-flow \
  --header 'content-type: application/json' \
  --data '{
  "flowName": "",
  "description": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}'

echo '{
  "flowName": "",
  "description": "",
  "triggerConfig": {
    "triggerType": "",
    "triggerProperties": ""
  },
  "sourceFlowConfig": {
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  },
  "destinationFlowConfigList": [
    {
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    }
  ],
  "tasks": [
    {
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    }
  ],
  "metadataCatalogConfig": {
    "glueDataCatalog": ""
  },
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/update-flow \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowName": "",\n  "description": "",\n  "triggerConfig": {\n    "triggerType": "",\n    "triggerProperties": ""\n  },\n  "sourceFlowConfig": {\n    "connectorType": "",\n    "apiVersion": "",\n    "connectorProfileName": "",\n    "sourceConnectorProperties": "",\n    "incrementalPullConfig": ""\n  },\n  "destinationFlowConfigList": [\n    {\n      "connectorType": "",\n      "apiVersion": "",\n      "connectorProfileName": "",\n      "destinationConnectorProperties": ""\n    }\n  ],\n  "tasks": [\n    {\n      "sourceFields": "",\n      "connectorOperator": "",\n      "destinationField": "",\n      "taskType": "",\n      "taskProperties": ""\n    }\n  ],\n  "metadataCatalogConfig": {\n    "glueDataCatalog": ""\n  },\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/update-flow

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "flowName": "",
  "description": "",
  "triggerConfig": [
    "triggerType": "",
    "triggerProperties": ""
  ],
  "sourceFlowConfig": [
    "connectorType": "",
    "apiVersion": "",
    "connectorProfileName": "",
    "sourceConnectorProperties": "",
    "incrementalPullConfig": ""
  ],
  "destinationFlowConfigList": [
    [
      "connectorType": "",
      "apiVersion": "",
      "connectorProfileName": "",
      "destinationConnectorProperties": ""
    ]
  ],
  "tasks": [
    [
      "sourceFields": "",
      "connectorOperator": "",
      "destinationField": "",
      "taskType": "",
      "taskProperties": ""
    ]
  ],
  "metadataCatalogConfig": ["glueDataCatalog": ""],
  "clientToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/update-flow")! 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()