Amazon DevOps Guruv2020-12-01

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels");

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  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/channels" {:content-type :json
                                                    :form-params {:Config {:Sns ""
                                                                           :Filters ""}}})

require "http/client"

url = "{{baseUrl}}/channels"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/channels"),
    Content = new StringContent("{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\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}}/channels");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/channels"

	payload := strings.NewReader("{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", 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))

}

PUT /baseUrl/channels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "Config": {
    "Sns": "",
    "Filters": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/channels")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\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  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/channels")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/channels")
  .header("content-type", "application/json")
  .body("{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Config: {
    Sns: '',
    Filters: ''
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/channels');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/channels',
  headers: {'content-type': 'application/json'},
  data: {Config: {Sns: '', Filters: ''}}
};

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

const url = '{{baseUrl}}/channels';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Config":{"Sns":"","Filters":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/channels',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Config": {\n    "Sns": "",\n    "Filters": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/channels")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels',
  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({Config: {Sns: '', Filters: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/channels',
  headers: {'content-type': 'application/json'},
  body: {Config: {Sns: '', Filters: ''}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/channels');

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

req.type('json');
req.send({
  Config: {
    Sns: '',
    Filters: ''
  }
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/channels',
  headers: {'content-type': 'application/json'},
  data: {Config: {Sns: '', Filters: ''}}
};

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

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

const url = '{{baseUrl}}/channels';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Config":{"Sns":"","Filters":""}}'
};

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 = @{ @"Config": @{ @"Sns": @"", @"Filters": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/channels" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/channels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Config' => [
        'Sns' => '',
        'Filters' => ''
    ]
  ]),
  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('PUT', '{{baseUrl}}/channels', [
  'body' => '{
  "Config": {
    "Sns": "",
    "Filters": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/channels');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Config' => [
    'Sns' => '',
    'Filters' => ''
  ]
]));

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

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

append(json_encode([
  'Config' => [
    'Sns' => '',
    'Filters' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/channels');
$request->setRequestMethod('PUT');
$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}}/channels' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Config": {
    "Sns": "",
    "Filters": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Config": {
    "Sns": "",
    "Filters": ""
  }
}'

import http.client

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

payload = "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/channels", payload, headers)

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

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

import requests

url = "{{baseUrl}}/channels"

payload = { "Config": {
        "Sns": "",
        "Filters": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels"

payload <- "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\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.put('/baseUrl/channels') do |req|
  req.body = "{\n  \"Config\": {\n    \"Sns\": \"\",\n    \"Filters\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({"Config": json!({
            "Sns": "",
            "Filters": ""
        })});

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "Config": {
    "Sns": "",
    "Filters": ""
  }
}' |  \
  http PUT {{baseUrl}}/channels \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Config": {\n    "Sns": "",\n    "Filters": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/channels

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Config": [
    "Sns": "",
    "Filters": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/insights/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/insights/:Id")

require "http/client"

url = "{{baseUrl}}/insights/:Id"

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}}/insights/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/insights/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/insights/:Id"

	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/insights/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/insights/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/insights/:Id"))
    .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}}/insights/:Id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/insights/:Id")
  .asString();

const 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}}/insights/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/insights/:Id'};

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

const url = '{{baseUrl}}/insights/:Id';
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}}/insights/:Id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/insights/:Id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/insights/:Id',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/insights/:Id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/insights/:Id');

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}}/insights/:Id'};

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

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

const url = '{{baseUrl}}/insights/:Id';
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}}/insights/:Id"]
                                                       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}}/insights/:Id" in

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

 "{{baseUrl}}/insights/:Id",
  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}}/insights/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/insights/:Id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/insights/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/insights/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/insights/:Id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/insights/:Id")

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

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

import requests

url = "{{baseUrl}}/insights/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/insights/:Id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/insights/:Id")

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/insights/:Id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/insights/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/insights/:Id

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/health");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/health")

require "http/client"

url = "{{baseUrl}}/accounts/health"

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}}/accounts/health"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/health");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/health"

	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/accounts/health HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/health")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/health"))
    .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}}/accounts/health")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/health")
  .asString();

const 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}}/accounts/health');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/accounts/health'};

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

const url = '{{baseUrl}}/accounts/health';
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}}/accounts/health',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/health")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/health',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/accounts/health'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/health');

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}}/accounts/health'};

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

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

const url = '{{baseUrl}}/accounts/health';
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}}/accounts/health"]
                                                       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}}/accounts/health" in

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

 "{{baseUrl}}/accounts/health",
  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}}/accounts/health');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/health');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/accounts/health');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/health' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/health' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/accounts/health")

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

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

import requests

url = "{{baseUrl}}/accounts/health"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/health"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/health")

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/accounts/health') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/health

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/health

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/overview");

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  \"FromTime\": \"\",\n  \"ToTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/overview" {:content-type :json
                                                              :form-params {:FromTime ""
                                                                            :ToTime ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/accounts/overview"

	payload := strings.NewReader("{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\"\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/accounts/overview HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "FromTime": "",
  "ToTime": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/overview")
  .header("content-type", "application/json")
  .body("{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FromTime: '',
  ToTime: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/overview',
  headers: {'content-type': 'application/json'},
  data: {FromTime: '', ToTime: ''}
};

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

const url = '{{baseUrl}}/accounts/overview';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromTime":"","ToTime":""}'
};

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/overview")
  .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/accounts/overview',
  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({FromTime: '', ToTime: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  FromTime: '',
  ToTime: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/overview',
  headers: {'content-type': 'application/json'},
  data: {FromTime: '', ToTime: ''}
};

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

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

const url = '{{baseUrl}}/accounts/overview';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromTime":"","ToTime":""}'
};

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 = @{ @"FromTime": @"",
                              @"ToTime": @"" };

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

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

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

 "{{baseUrl}}/accounts/overview",
  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([
    'FromTime' => '',
    'ToTime' => ''
  ]),
  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}}/accounts/overview', [
  'body' => '{
  "FromTime": "",
  "ToTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/overview');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'FromTime' => '',
  'ToTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/accounts/overview');
$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}}/accounts/overview' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromTime": "",
  "ToTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/overview' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromTime": "",
  "ToTime": ""
}'

import http.client

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

payload = "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/accounts/overview"

payload = {
    "FromTime": "",
    "ToTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/overview"

payload <- "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\"\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}}/accounts/overview")

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  \"FromTime\": \"\",\n  \"ToTime\": \"\"\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/accounts/overview') do |req|
  req.body = "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "FromTime": "",
        "ToTime": ""
    });

    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);
}

echo '{
  "FromTime": "",
  "ToTime": ""
}' |  \
  http POST {{baseUrl}}/accounts/overview \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "FromTime": "",\n  "ToTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/accounts/overview

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/anomalies/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/anomalies/:Id")

require "http/client"

url = "{{baseUrl}}/anomalies/:Id"

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}}/anomalies/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/anomalies/:Id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/anomalies/:Id"

	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/anomalies/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/anomalies/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/anomalies/:Id"))
    .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}}/anomalies/:Id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/anomalies/:Id")
  .asString();

const 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}}/anomalies/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/anomalies/:Id'};

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

const url = '{{baseUrl}}/anomalies/:Id';
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}}/anomalies/:Id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/anomalies/:Id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/anomalies/:Id',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/anomalies/:Id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/anomalies/:Id');

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}}/anomalies/:Id'};

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

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

const url = '{{baseUrl}}/anomalies/:Id';
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}}/anomalies/:Id"]
                                                       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}}/anomalies/:Id" in

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

 "{{baseUrl}}/anomalies/:Id",
  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}}/anomalies/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/anomalies/:Id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/anomalies/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/anomalies/:Id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/anomalies/:Id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/anomalies/:Id")

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

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

import requests

url = "{{baseUrl}}/anomalies/:Id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/anomalies/:Id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/anomalies/:Id")

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/anomalies/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/anomalies/:Id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/anomalies/:Id

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event-sources");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/event-sources")

require "http/client"

url = "{{baseUrl}}/event-sources"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/event-sources"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/event-sources");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/event-sources"

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

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

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

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

}

POST /baseUrl/event-sources HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/event-sources")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/event-sources"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/event-sources")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/event-sources")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/event-sources');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/event-sources'};

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

const url = '{{baseUrl}}/event-sources';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/event-sources',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/event-sources")
  .post(null)
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/event-sources'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/event-sources');

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

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

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

const options = {method: 'POST', url: '{{baseUrl}}/event-sources'};

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

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

const url = '{{baseUrl}}/event-sources';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event-sources"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/event-sources" in

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

 "{{baseUrl}}/event-sources",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/event-sources');

echo $response->getBody();

setUrl('{{baseUrl}}/event-sources');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/event-sources');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/event-sources' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/event-sources' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/event-sources")

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

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

import requests

url = "{{baseUrl}}/event-sources"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/event-sources"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/event-sources")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/event-sources') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/event-sources

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/event-sources

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event-sources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/feedback");

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  \"InsightId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/feedback" {:content-type :json
                                                     :form-params {:InsightId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/feedback"

	payload := strings.NewReader("{\n  \"InsightId\": \"\"\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/feedback HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "InsightId": ""
}

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

client.close();

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

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

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

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

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InsightId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/feedback")
  .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/feedback',
  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({InsightId: ''}));
req.end();

const request = require('request');

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

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

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

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

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

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

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

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

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

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

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 = @{ @"InsightId": @"" };

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

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

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

 "{{baseUrl}}/feedback",
  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([
    'InsightId' => ''
  ]),
  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}}/feedback', [
  'body' => '{
  "InsightId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'InsightId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/feedback');
$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}}/feedback' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InsightId": ""
}'

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

import http.client

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

payload = "{\n  \"InsightId\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/feedback"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/feedback"

payload <- "{\n  \"InsightId\": \"\"\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}}/feedback")

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  \"InsightId\": \"\"\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/feedback') do |req|
  req.body = "{\n  \"InsightId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"InsightId": ""});

    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);
}

echo '{
  "InsightId": ""
}' |  \
  http POST {{baseUrl}}/feedback \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InsightId": ""\n}' \
  --output-document \
  - {{baseUrl}}/feedback

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/insights/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/insights/:Id")

require "http/client"

url = "{{baseUrl}}/insights/:Id"

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}}/insights/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/insights/:Id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/insights/:Id"

	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/insights/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/insights/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/insights/:Id"))
    .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}}/insights/:Id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/insights/:Id")
  .asString();

const 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}}/insights/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/insights/:Id'};

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

const url = '{{baseUrl}}/insights/:Id';
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}}/insights/:Id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/insights/:Id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/insights/:Id',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/insights/:Id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/insights/:Id');

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}}/insights/:Id'};

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

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

const url = '{{baseUrl}}/insights/:Id';
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}}/insights/:Id"]
                                                       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}}/insights/:Id" in

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

 "{{baseUrl}}/insights/:Id",
  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}}/insights/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/insights/:Id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/insights/:Id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/insights/:Id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/insights/:Id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/insights/:Id")

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

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

import requests

url = "{{baseUrl}}/insights/:Id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/insights/:Id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/insights/:Id")

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/insights/:Id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/insights/:Id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/insights/:Id

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organization/health");

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  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/organization/health" {:content-type :json
                                                                :form-params {:AccountIds []
                                                                              :OrganizationalUnitIds []}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/organization/health"

	payload := strings.NewReader("{\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\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/organization/health HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "AccountIds": [],
  "OrganizationalUnitIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organization/health")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/organization/health")
  .header("content-type", "application/json")
  .body("{\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}")
  .asString();

const data = JSON.stringify({
  AccountIds: [],
  OrganizationalUnitIds: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/health',
  headers: {'content-type': 'application/json'},
  data: {AccountIds: [], OrganizationalUnitIds: []}
};

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

const url = '{{baseUrl}}/organization/health';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountIds":[],"OrganizationalUnitIds":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organization/health',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccountIds": [],\n  "OrganizationalUnitIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organization/health")
  .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/organization/health',
  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({AccountIds: [], OrganizationalUnitIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/health',
  headers: {'content-type': 'application/json'},
  body: {AccountIds: [], OrganizationalUnitIds: []},
  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}}/organization/health');

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

req.type('json');
req.send({
  AccountIds: [],
  OrganizationalUnitIds: []
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/health',
  headers: {'content-type': 'application/json'},
  data: {AccountIds: [], OrganizationalUnitIds: []}
};

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

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

const url = '{{baseUrl}}/organization/health';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountIds":[],"OrganizationalUnitIds":[]}'
};

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 = @{ @"AccountIds": @[  ],
                              @"OrganizationalUnitIds": @[  ] };

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

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

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

 "{{baseUrl}}/organization/health",
  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([
    'AccountIds' => [
        
    ],
    'OrganizationalUnitIds' => [
        
    ]
  ]),
  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}}/organization/health', [
  'body' => '{
  "AccountIds": [],
  "OrganizationalUnitIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organization/health');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'AccountIds' => [
    
  ],
  'OrganizationalUnitIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/organization/health');
$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}}/organization/health' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountIds": [],
  "OrganizationalUnitIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organization/health' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountIds": [],
  "OrganizationalUnitIds": []
}'

import http.client

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

payload = "{\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/organization/health"

payload = {
    "AccountIds": [],
    "OrganizationalUnitIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organization/health"

payload <- "{\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\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}}/organization/health")

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  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\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/organization/health') do |req|
  req.body = "{\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "AccountIds": (),
        "OrganizationalUnitIds": ()
    });

    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);
}

echo '{
  "AccountIds": [],
  "OrganizationalUnitIds": []
}' |  \
  http POST {{baseUrl}}/organization/health \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccountIds": [],\n  "OrganizationalUnitIds": []\n}' \
  --output-document \
  - {{baseUrl}}/organization/health

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organization/overview");

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  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/organization/overview" {:content-type :json
                                                                  :form-params {:FromTime ""
                                                                                :ToTime ""
                                                                                :AccountIds []
                                                                                :OrganizationalUnitIds []}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/organization/overview"

	payload := strings.NewReader("{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\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/organization/overview HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "FromTime": "",
  "ToTime": "",
  "AccountIds": [],
  "OrganizationalUnitIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organization/overview")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/organization/overview")
  .header("content-type", "application/json")
  .body("{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}")
  .asString();

const data = JSON.stringify({
  FromTime: '',
  ToTime: '',
  AccountIds: [],
  OrganizationalUnitIds: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/overview',
  headers: {'content-type': 'application/json'},
  data: {FromTime: '', ToTime: '', AccountIds: [], OrganizationalUnitIds: []}
};

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

const url = '{{baseUrl}}/organization/overview';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromTime":"","ToTime":"","AccountIds":[],"OrganizationalUnitIds":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organization/overview',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FromTime": "",\n  "ToTime": "",\n  "AccountIds": [],\n  "OrganizationalUnitIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organization/overview")
  .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/organization/overview',
  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({FromTime: '', ToTime: '', AccountIds: [], OrganizationalUnitIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/overview',
  headers: {'content-type': 'application/json'},
  body: {FromTime: '', ToTime: '', AccountIds: [], OrganizationalUnitIds: []},
  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}}/organization/overview');

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

req.type('json');
req.send({
  FromTime: '',
  ToTime: '',
  AccountIds: [],
  OrganizationalUnitIds: []
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/overview',
  headers: {'content-type': 'application/json'},
  data: {FromTime: '', ToTime: '', AccountIds: [], OrganizationalUnitIds: []}
};

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

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

const url = '{{baseUrl}}/organization/overview';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FromTime":"","ToTime":"","AccountIds":[],"OrganizationalUnitIds":[]}'
};

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 = @{ @"FromTime": @"",
                              @"ToTime": @"",
                              @"AccountIds": @[  ],
                              @"OrganizationalUnitIds": @[  ] };

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

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

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

 "{{baseUrl}}/organization/overview",
  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([
    'FromTime' => '',
    'ToTime' => '',
    'AccountIds' => [
        
    ],
    'OrganizationalUnitIds' => [
        
    ]
  ]),
  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}}/organization/overview', [
  'body' => '{
  "FromTime": "",
  "ToTime": "",
  "AccountIds": [],
  "OrganizationalUnitIds": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organization/overview');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FromTime' => '',
  'ToTime' => '',
  'AccountIds' => [
    
  ],
  'OrganizationalUnitIds' => [
    
  ]
]));

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

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

append(json_encode([
  'FromTime' => '',
  'ToTime' => '',
  'AccountIds' => [
    
  ],
  'OrganizationalUnitIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/organization/overview');
$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}}/organization/overview' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromTime": "",
  "ToTime": "",
  "AccountIds": [],
  "OrganizationalUnitIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organization/overview' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FromTime": "",
  "ToTime": "",
  "AccountIds": [],
  "OrganizationalUnitIds": []
}'

import http.client

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

payload = "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/organization/overview"

payload = {
    "FromTime": "",
    "ToTime": "",
    "AccountIds": [],
    "OrganizationalUnitIds": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organization/overview"

payload <- "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\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}}/organization/overview")

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  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\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/organization/overview') do |req|
  req.body = "{\n  \"FromTime\": \"\",\n  \"ToTime\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "FromTime": "",
        "ToTime": "",
        "AccountIds": (),
        "OrganizationalUnitIds": ()
    });

    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);
}

echo '{
  "FromTime": "",
  "ToTime": "",
  "AccountIds": [],
  "OrganizationalUnitIds": []
}' |  \
  http POST {{baseUrl}}/organization/overview \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "FromTime": "",\n  "ToTime": "",\n  "AccountIds": [],\n  "OrganizationalUnitIds": []\n}' \
  --output-document \
  - {{baseUrl}}/organization/overview

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "FromTime": "",
  "ToTime": "",
  "AccountIds": [],
  "OrganizationalUnitIds": []
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organization/health/resource-collection");

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  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/organization/health/resource-collection" {:content-type :json
                                                                                    :form-params {:OrganizationResourceCollectionType ""
                                                                                                  :AccountIds []
                                                                                                  :OrganizationalUnitIds []
                                                                                                  :NextToken ""
                                                                                                  :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/organization/health/resource-collection"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/organization/health/resource-collection"),
    Content = new StringContent("{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/organization/health/resource-collection");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organization/health/resource-collection"

	payload := strings.NewReader("{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/organization/health/resource-collection HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 135

{
  "OrganizationResourceCollectionType": "",
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organization/health/resource-collection")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organization/health/resource-collection"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/organization/health/resource-collection")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/organization/health/resource-collection")
  .header("content-type", "application/json")
  .body("{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  OrganizationResourceCollectionType: '',
  AccountIds: [],
  OrganizationalUnitIds: [],
  NextToken: '',
  MaxResults: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/organization/health/resource-collection');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/health/resource-collection',
  headers: {'content-type': 'application/json'},
  data: {
    OrganizationResourceCollectionType: '',
    AccountIds: [],
    OrganizationalUnitIds: [],
    NextToken: '',
    MaxResults: 0
  }
};

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

const url = '{{baseUrl}}/organization/health/resource-collection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"OrganizationResourceCollectionType":"","AccountIds":[],"OrganizationalUnitIds":[],"NextToken":"","MaxResults":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organization/health/resource-collection',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "OrganizationResourceCollectionType": "",\n  "AccountIds": [],\n  "OrganizationalUnitIds": [],\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organization/health/resource-collection")
  .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/organization/health/resource-collection',
  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({
  OrganizationResourceCollectionType: '',
  AccountIds: [],
  OrganizationalUnitIds: [],
  NextToken: '',
  MaxResults: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/health/resource-collection',
  headers: {'content-type': 'application/json'},
  body: {
    OrganizationResourceCollectionType: '',
    AccountIds: [],
    OrganizationalUnitIds: [],
    NextToken: '',
    MaxResults: 0
  },
  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}}/organization/health/resource-collection');

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

req.type('json');
req.send({
  OrganizationResourceCollectionType: '',
  AccountIds: [],
  OrganizationalUnitIds: [],
  NextToken: '',
  MaxResults: 0
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/health/resource-collection',
  headers: {'content-type': 'application/json'},
  data: {
    OrganizationResourceCollectionType: '',
    AccountIds: [],
    OrganizationalUnitIds: [],
    NextToken: '',
    MaxResults: 0
  }
};

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

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

const url = '{{baseUrl}}/organization/health/resource-collection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"OrganizationResourceCollectionType":"","AccountIds":[],"OrganizationalUnitIds":[],"NextToken":"","MaxResults":0}'
};

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 = @{ @"OrganizationResourceCollectionType": @"",
                              @"AccountIds": @[  ],
                              @"OrganizationalUnitIds": @[  ],
                              @"NextToken": @"",
                              @"MaxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organization/health/resource-collection"]
                                                       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}}/organization/health/resource-collection" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

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

 "{{baseUrl}}/organization/health/resource-collection",
  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([
    'OrganizationResourceCollectionType' => '',
    'AccountIds' => [
        
    ],
    'OrganizationalUnitIds' => [
        
    ],
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  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}}/organization/health/resource-collection', [
  'body' => '{
  "OrganizationResourceCollectionType": "",
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organization/health/resource-collection');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'OrganizationResourceCollectionType' => '',
  'AccountIds' => [
    
  ],
  'OrganizationalUnitIds' => [
    
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));

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

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

append(json_encode([
  'OrganizationResourceCollectionType' => '',
  'AccountIds' => [
    
  ],
  'OrganizationalUnitIds' => [
    
  ],
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/organization/health/resource-collection');
$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}}/organization/health/resource-collection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "OrganizationResourceCollectionType": "",
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organization/health/resource-collection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "OrganizationResourceCollectionType": "",
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

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

payload = "{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

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

conn.request("POST", "/baseUrl/organization/health/resource-collection", payload, headers)

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

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

import requests

url = "{{baseUrl}}/organization/health/resource-collection"

payload = {
    "OrganizationResourceCollectionType": "",
    "AccountIds": [],
    "OrganizationalUnitIds": [],
    "NextToken": "",
    "MaxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organization/health/resource-collection"

payload <- "{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/organization/health/resource-collection")

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  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/organization/health/resource-collection') do |req|
  req.body = "{\n  \"OrganizationResourceCollectionType\": \"\",\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/organization/health/resource-collection";

    let payload = json!({
        "OrganizationResourceCollectionType": "",
        "AccountIds": (),
        "OrganizationalUnitIds": (),
        "NextToken": "",
        "MaxResults": 0
    });

    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);
}

echo '{
  "OrganizationResourceCollectionType": "",
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST {{baseUrl}}/organization/health/resource-collection \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "OrganizationResourceCollectionType": "",\n  "AccountIds": [],\n  "OrganizationalUnitIds": [],\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/organization/health/resource-collection

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "OrganizationResourceCollectionType": "",
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/organization/health/resource-collection")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType")

require "http/client"

url = "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType"

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}}/accounts/health/resource-collection/:ResourceCollectionType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType"

	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/accounts/health/resource-collection/:ResourceCollectionType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType"))
    .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}}/accounts/health/resource-collection/:ResourceCollectionType")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType")
  .asString();

const 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}}/accounts/health/resource-collection/:ResourceCollectionType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType'
};

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

const url = '{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType';
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}}/accounts/health/resource-collection/:ResourceCollectionType',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accounts/health/resource-collection/:ResourceCollectionType',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/accounts/health/resource-collection/:ResourceCollectionType'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType');

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}}/accounts/health/resource-collection/:ResourceCollectionType'
};

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

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

const url = '{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType';
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}}/accounts/health/resource-collection/:ResourceCollectionType"]
                                                       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}}/accounts/health/resource-collection/:ResourceCollectionType" in

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

 "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType",
  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}}/accounts/health/resource-collection/:ResourceCollectionType');

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/accounts/health/resource-collection/:ResourceCollectionType")

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

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

import requests

url = "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType")

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/accounts/health/resource-collection/:ResourceCollectionType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accounts/health/resource-collection/:ResourceCollectionType")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/service-integrations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/service-integrations")

require "http/client"

url = "{{baseUrl}}/service-integrations"

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}}/service-integrations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/service-integrations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/service-integrations"

	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/service-integrations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/service-integrations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/service-integrations"))
    .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}}/service-integrations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/service-integrations")
  .asString();

const 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}}/service-integrations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/service-integrations'};

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

const url = '{{baseUrl}}/service-integrations';
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}}/service-integrations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/service-integrations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/service-integrations',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/service-integrations'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/service-integrations');

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}}/service-integrations'};

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

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

const url = '{{baseUrl}}/service-integrations';
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}}/service-integrations"]
                                                       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}}/service-integrations" in

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

 "{{baseUrl}}/service-integrations",
  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}}/service-integrations');

echo $response->getBody();

setUrl('{{baseUrl}}/service-integrations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/service-integrations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/service-integrations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/service-integrations' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/service-integrations")

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

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

import requests

url = "{{baseUrl}}/service-integrations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/service-integrations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/service-integrations")

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/service-integrations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/service-integrations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/service-integrations

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cost-estimation");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/cost-estimation")

require "http/client"

url = "{{baseUrl}}/cost-estimation"

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}}/cost-estimation"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/cost-estimation");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/cost-estimation"

	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/cost-estimation HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/cost-estimation")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cost-estimation"))
    .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}}/cost-estimation")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/cost-estimation")
  .asString();

const 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}}/cost-estimation');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/cost-estimation'};

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

const url = '{{baseUrl}}/cost-estimation';
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}}/cost-estimation',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/cost-estimation")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/cost-estimation',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/cost-estimation'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/cost-estimation');

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}}/cost-estimation'};

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

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

const url = '{{baseUrl}}/cost-estimation';
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}}/cost-estimation"]
                                                       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}}/cost-estimation" in

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

 "{{baseUrl}}/cost-estimation",
  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}}/cost-estimation');

echo $response->getBody();

setUrl('{{baseUrl}}/cost-estimation');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/cost-estimation');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/cost-estimation' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/cost-estimation' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/cost-estimation")

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

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

import requests

url = "{{baseUrl}}/cost-estimation"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/cost-estimation"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/cost-estimation")

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/cost-estimation') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/cost-estimation

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/cost-estimation

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource-collections/:ResourceCollectionType");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/resource-collections/:ResourceCollectionType")

require "http/client"

url = "{{baseUrl}}/resource-collections/:ResourceCollectionType"

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}}/resource-collections/:ResourceCollectionType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource-collections/:ResourceCollectionType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource-collections/:ResourceCollectionType"

	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/resource-collections/:ResourceCollectionType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource-collections/:ResourceCollectionType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource-collections/:ResourceCollectionType"))
    .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}}/resource-collections/:ResourceCollectionType")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/resource-collections/:ResourceCollectionType")
  .asString();

const 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}}/resource-collections/:ResourceCollectionType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource-collections/:ResourceCollectionType'
};

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

const url = '{{baseUrl}}/resource-collections/:ResourceCollectionType';
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}}/resource-collections/:ResourceCollectionType',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource-collections/:ResourceCollectionType")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource-collections/:ResourceCollectionType',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/resource-collections/:ResourceCollectionType'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource-collections/:ResourceCollectionType');

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}}/resource-collections/:ResourceCollectionType'
};

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

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

const url = '{{baseUrl}}/resource-collections/:ResourceCollectionType';
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}}/resource-collections/:ResourceCollectionType"]
                                                       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}}/resource-collections/:ResourceCollectionType" in

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

 "{{baseUrl}}/resource-collections/:ResourceCollectionType",
  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}}/resource-collections/:ResourceCollectionType');

echo $response->getBody();

setUrl('{{baseUrl}}/resource-collections/:ResourceCollectionType');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/resource-collections/:ResourceCollectionType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource-collections/:ResourceCollectionType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource-collections/:ResourceCollectionType' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/resource-collections/:ResourceCollectionType")

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

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

import requests

url = "{{baseUrl}}/resource-collections/:ResourceCollectionType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource-collections/:ResourceCollectionType"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource-collections/:ResourceCollectionType")

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/resource-collections/:ResourceCollectionType') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/resource-collections/:ResourceCollectionType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource-collections/:ResourceCollectionType

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/anomalies/insight/:InsightId");

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  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/anomalies/insight/:InsightId" {:content-type :json
                                                                         :form-params {:StartTimeRange {:FromTime ""
                                                                                                        :ToTime ""}
                                                                                       :MaxResults 0
                                                                                       :NextToken ""
                                                                                       :AccountId ""
                                                                                       :Filters {:ServiceCollection {:ServiceNames ""}}}})

require "http/client"

url = "{{baseUrl}}/anomalies/insight/:InsightId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\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}}/anomalies/insight/:InsightId"),
    Content = new StringContent("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\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}}/anomalies/insight/:InsightId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/anomalies/insight/:InsightId"

	payload := strings.NewReader("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\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/anomalies/insight/:InsightId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 201

{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": "",
  "Filters": {
    "ServiceCollection": {
      "ServiceNames": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/anomalies/insight/:InsightId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/anomalies/insight/:InsightId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\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  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/anomalies/insight/:InsightId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/anomalies/insight/:InsightId")
  .header("content-type", "application/json")
  .body("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  StartTimeRange: {
    FromTime: '',
    ToTime: ''
  },
  MaxResults: 0,
  NextToken: '',
  AccountId: '',
  Filters: {
    ServiceCollection: {
      ServiceNames: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/anomalies/insight/:InsightId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/anomalies/insight/:InsightId',
  headers: {'content-type': 'application/json'},
  data: {
    StartTimeRange: {FromTime: '', ToTime: ''},
    MaxResults: 0,
    NextToken: '',
    AccountId: '',
    Filters: {ServiceCollection: {ServiceNames: ''}}
  }
};

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

const url = '{{baseUrl}}/anomalies/insight/:InsightId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StartTimeRange":{"FromTime":"","ToTime":""},"MaxResults":0,"NextToken":"","AccountId":"","Filters":{"ServiceCollection":{"ServiceNames":""}}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/anomalies/insight/:InsightId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StartTimeRange": {\n    "FromTime": "",\n    "ToTime": ""\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "AccountId": "",\n  "Filters": {\n    "ServiceCollection": {\n      "ServiceNames": ""\n    }\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/anomalies/insight/:InsightId")
  .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/anomalies/insight/:InsightId',
  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({
  StartTimeRange: {FromTime: '', ToTime: ''},
  MaxResults: 0,
  NextToken: '',
  AccountId: '',
  Filters: {ServiceCollection: {ServiceNames: ''}}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/anomalies/insight/:InsightId',
  headers: {'content-type': 'application/json'},
  body: {
    StartTimeRange: {FromTime: '', ToTime: ''},
    MaxResults: 0,
    NextToken: '',
    AccountId: '',
    Filters: {ServiceCollection: {ServiceNames: ''}}
  },
  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}}/anomalies/insight/:InsightId');

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

req.type('json');
req.send({
  StartTimeRange: {
    FromTime: '',
    ToTime: ''
  },
  MaxResults: 0,
  NextToken: '',
  AccountId: '',
  Filters: {
    ServiceCollection: {
      ServiceNames: ''
    }
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/anomalies/insight/:InsightId',
  headers: {'content-type': 'application/json'},
  data: {
    StartTimeRange: {FromTime: '', ToTime: ''},
    MaxResults: 0,
    NextToken: '',
    AccountId: '',
    Filters: {ServiceCollection: {ServiceNames: ''}}
  }
};

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

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

const url = '{{baseUrl}}/anomalies/insight/:InsightId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StartTimeRange":{"FromTime":"","ToTime":""},"MaxResults":0,"NextToken":"","AccountId":"","Filters":{"ServiceCollection":{"ServiceNames":""}}}'
};

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 = @{ @"StartTimeRange": @{ @"FromTime": @"", @"ToTime": @"" },
                              @"MaxResults": @0,
                              @"NextToken": @"",
                              @"AccountId": @"",
                              @"Filters": @{ @"ServiceCollection": @{ @"ServiceNames": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/anomalies/insight/:InsightId"]
                                                       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}}/anomalies/insight/:InsightId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/anomalies/insight/:InsightId",
  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([
    'StartTimeRange' => [
        'FromTime' => '',
        'ToTime' => ''
    ],
    'MaxResults' => 0,
    'NextToken' => '',
    'AccountId' => '',
    'Filters' => [
        'ServiceCollection' => [
                'ServiceNames' => ''
        ]
    ]
  ]),
  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}}/anomalies/insight/:InsightId', [
  'body' => '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": "",
  "Filters": {
    "ServiceCollection": {
      "ServiceNames": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/anomalies/insight/:InsightId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StartTimeRange' => [
    'FromTime' => '',
    'ToTime' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'AccountId' => '',
  'Filters' => [
    'ServiceCollection' => [
        'ServiceNames' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'StartTimeRange' => [
    'FromTime' => '',
    'ToTime' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'AccountId' => '',
  'Filters' => [
    'ServiceCollection' => [
        'ServiceNames' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/anomalies/insight/:InsightId');
$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}}/anomalies/insight/:InsightId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": "",
  "Filters": {
    "ServiceCollection": {
      "ServiceNames": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/anomalies/insight/:InsightId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": "",
  "Filters": {
    "ServiceCollection": {
      "ServiceNames": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}"

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

conn.request("POST", "/baseUrl/anomalies/insight/:InsightId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/anomalies/insight/:InsightId"

payload = {
    "StartTimeRange": {
        "FromTime": "",
        "ToTime": ""
    },
    "MaxResults": 0,
    "NextToken": "",
    "AccountId": "",
    "Filters": { "ServiceCollection": { "ServiceNames": "" } }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/anomalies/insight/:InsightId"

payload <- "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\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}}/anomalies/insight/:InsightId")

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  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\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/anomalies/insight/:InsightId') do |req|
  req.body = "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\",\n  \"Filters\": {\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "StartTimeRange": json!({
            "FromTime": "",
            "ToTime": ""
        }),
        "MaxResults": 0,
        "NextToken": "",
        "AccountId": "",
        "Filters": json!({"ServiceCollection": json!({"ServiceNames": ""})})
    });

    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);
}

echo '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": "",
  "Filters": {
    "ServiceCollection": {
      "ServiceNames": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/anomalies/insight/:InsightId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "StartTimeRange": {\n    "FromTime": "",\n    "ToTime": ""\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "AccountId": "",\n  "Filters": {\n    "ServiceCollection": {\n      "ServiceNames": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/anomalies/insight/:InsightId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "StartTimeRange": [
    "FromTime": "",
    "ToTime": ""
  ],
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": "",
  "Filters": ["ServiceCollection": ["ServiceNames": ""]]
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/list-log-anomalies");

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  \"InsightId\": \"\",\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/list-log-anomalies" {:content-type :json
                                                               :form-params {:InsightId ""
                                                                             :MaxResults 0
                                                                             :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/list-log-anomalies"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"InsightId\": \"\",\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-log-anomalies"),
    Content = new StringContent("{\n  \"InsightId\": \"\",\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-log-anomalies");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InsightId\": \"\",\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-log-anomalies"

	payload := strings.NewReader("{\n  \"InsightId\": \"\",\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-log-anomalies HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "InsightId": "",
  "MaxResults": 0,
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/list-log-anomalies")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InsightId\": \"\",\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/list-log-anomalies")
  .header("content-type", "application/json")
  .body("{\n  \"InsightId\": \"\",\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InsightId: '',
  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-log-anomalies');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/list-log-anomalies',
  headers: {'content-type': 'application/json'},
  data: {InsightId: '', MaxResults: 0, NextToken: ''}
};

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

const url = '{{baseUrl}}/list-log-anomalies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InsightId":"","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-log-anomalies',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InsightId": "",\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  \"InsightId\": \"\",\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/list-log-anomalies")
  .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-log-anomalies',
  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({InsightId: '', MaxResults: 0, NextToken: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  InsightId: '',
  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-log-anomalies',
  headers: {'content-type': 'application/json'},
  data: {InsightId: '', 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-log-anomalies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InsightId":"","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 = @{ @"InsightId": @"",
                              @"MaxResults": @0,
                              @"NextToken": @"" };

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

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

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

 "{{baseUrl}}/list-log-anomalies",
  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([
    'InsightId' => '',
    '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-log-anomalies', [
  'body' => '{
  "InsightId": "",
  "MaxResults": 0,
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/list-log-anomalies');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InsightId' => '',
  'MaxResults' => 0,
  'NextToken' => ''
]));

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

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

append(json_encode([
  'InsightId' => '',
  'MaxResults' => 0,
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/list-log-anomalies');
$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-log-anomalies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InsightId": "",
  "MaxResults": 0,
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/list-log-anomalies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InsightId": "",
  "MaxResults": 0,
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"InsightId\": \"\",\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/list-log-anomalies", payload, headers)

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

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

import requests

url = "{{baseUrl}}/list-log-anomalies"

payload = {
    "InsightId": "",
    "MaxResults": 0,
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/list-log-anomalies"

payload <- "{\n  \"InsightId\": \"\",\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-log-anomalies")

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  \"InsightId\": \"\",\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-log-anomalies') do |req|
  req.body = "{\n  \"InsightId\": \"\",\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-log-anomalies";

    let payload = json!({
        "InsightId": "",
        "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);
}

echo '{
  "InsightId": "",
  "MaxResults": 0,
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/list-log-anomalies \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InsightId": "",\n  "MaxResults": 0,\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/list-log-anomalies

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InsightId": "",
  "MaxResults": 0,
  "NextToken": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/events");

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  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/events" {:content-type :json
                                                   :form-params {:Filters {:InsightId ""
                                                                           :EventTimeRange ""
                                                                           :EventClass ""
                                                                           :EventSource ""
                                                                           :DataSource ""
                                                                           :ResourceCollection {:CloudFormation ""
                                                                                                :Tags ""}}
                                                                 :MaxResults 0
                                                                 :NextToken ""
                                                                 :AccountId ""}})

require "http/client"

url = "{{baseUrl}}/events"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\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}}/events"),
    Content = new StringContent("{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\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}}/events");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/events"

	payload := strings.NewReader("{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\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/events HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 272

{
  "Filters": {
    "InsightId": "",
    "EventTimeRange": "",
    "EventClass": "",
    "EventSource": "",
    "DataSource": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/events")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/events"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\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  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/events")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/events")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: {
    InsightId: '',
    EventTimeRange: '',
    EventClass: '',
    EventSource: '',
    DataSource: '',
    ResourceCollection: {
      CloudFormation: '',
      Tags: ''
    }
  },
  MaxResults: 0,
  NextToken: '',
  AccountId: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/events',
  headers: {'content-type': 'application/json'},
  data: {
    Filters: {
      InsightId: '',
      EventTimeRange: '',
      EventClass: '',
      EventSource: '',
      DataSource: '',
      ResourceCollection: {CloudFormation: '', Tags: ''}
    },
    MaxResults: 0,
    NextToken: '',
    AccountId: ''
  }
};

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

const url = '{{baseUrl}}/events';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":{"InsightId":"","EventTimeRange":"","EventClass":"","EventSource":"","DataSource":"","ResourceCollection":{"CloudFormation":"","Tags":""}},"MaxResults":0,"NextToken":"","AccountId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/events',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": {\n    "InsightId": "",\n    "EventTimeRange": "",\n    "EventClass": "",\n    "EventSource": "",\n    "DataSource": "",\n    "ResourceCollection": {\n      "CloudFormation": "",\n      "Tags": ""\n    }\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "AccountId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/events")
  .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/events',
  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({
  Filters: {
    InsightId: '',
    EventTimeRange: '',
    EventClass: '',
    EventSource: '',
    DataSource: '',
    ResourceCollection: {CloudFormation: '', Tags: ''}
  },
  MaxResults: 0,
  NextToken: '',
  AccountId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/events',
  headers: {'content-type': 'application/json'},
  body: {
    Filters: {
      InsightId: '',
      EventTimeRange: '',
      EventClass: '',
      EventSource: '',
      DataSource: '',
      ResourceCollection: {CloudFormation: '', Tags: ''}
    },
    MaxResults: 0,
    NextToken: '',
    AccountId: ''
  },
  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}}/events');

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

req.type('json');
req.send({
  Filters: {
    InsightId: '',
    EventTimeRange: '',
    EventClass: '',
    EventSource: '',
    DataSource: '',
    ResourceCollection: {
      CloudFormation: '',
      Tags: ''
    }
  },
  MaxResults: 0,
  NextToken: '',
  AccountId: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/events',
  headers: {'content-type': 'application/json'},
  data: {
    Filters: {
      InsightId: '',
      EventTimeRange: '',
      EventClass: '',
      EventSource: '',
      DataSource: '',
      ResourceCollection: {CloudFormation: '', Tags: ''}
    },
    MaxResults: 0,
    NextToken: '',
    AccountId: ''
  }
};

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

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

const url = '{{baseUrl}}/events';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":{"InsightId":"","EventTimeRange":"","EventClass":"","EventSource":"","DataSource":"","ResourceCollection":{"CloudFormation":"","Tags":""}},"MaxResults":0,"NextToken":"","AccountId":""}'
};

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 = @{ @"Filters": @{ @"InsightId": @"", @"EventTimeRange": @"", @"EventClass": @"", @"EventSource": @"", @"DataSource": @"", @"ResourceCollection": @{ @"CloudFormation": @"", @"Tags": @"" } },
                              @"MaxResults": @0,
                              @"NextToken": @"",
                              @"AccountId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/events"]
                                                       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}}/events" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}" in

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

 "{{baseUrl}}/events",
  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([
    'Filters' => [
        'InsightId' => '',
        'EventTimeRange' => '',
        'EventClass' => '',
        'EventSource' => '',
        'DataSource' => '',
        'ResourceCollection' => [
                'CloudFormation' => '',
                'Tags' => ''
        ]
    ],
    'MaxResults' => 0,
    'NextToken' => '',
    'AccountId' => ''
  ]),
  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}}/events', [
  'body' => '{
  "Filters": {
    "InsightId": "",
    "EventTimeRange": "",
    "EventClass": "",
    "EventSource": "",
    "DataSource": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    'InsightId' => '',
    'EventTimeRange' => '',
    'EventClass' => '',
    'EventSource' => '',
    'DataSource' => '',
    'ResourceCollection' => [
        'CloudFormation' => '',
        'Tags' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'AccountId' => ''
]));

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

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

append(json_encode([
  'Filters' => [
    'InsightId' => '',
    'EventTimeRange' => '',
    'EventClass' => '',
    'EventSource' => '',
    'DataSource' => '',
    'ResourceCollection' => [
        'CloudFormation' => '',
        'Tags' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'AccountId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/events');
$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}}/events' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": {
    "InsightId": "",
    "EventTimeRange": "",
    "EventClass": "",
    "EventSource": "",
    "DataSource": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/events' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": {
    "InsightId": "",
    "EventTimeRange": "",
    "EventClass": "",
    "EventSource": "",
    "DataSource": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": ""
}'

import http.client

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

payload = "{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/events"

payload = {
    "Filters": {
        "InsightId": "",
        "EventTimeRange": "",
        "EventClass": "",
        "EventSource": "",
        "DataSource": "",
        "ResourceCollection": {
            "CloudFormation": "",
            "Tags": ""
        }
    },
    "MaxResults": 0,
    "NextToken": "",
    "AccountId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/events"

payload <- "{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\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}}/events")

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  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\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/events') do |req|
  req.body = "{\n  \"Filters\": {\n    \"InsightId\": \"\",\n    \"EventTimeRange\": \"\",\n    \"EventClass\": \"\",\n    \"EventSource\": \"\",\n    \"DataSource\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"AccountId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Filters": json!({
            "InsightId": "",
            "EventTimeRange": "",
            "EventClass": "",
            "EventSource": "",
            "DataSource": "",
            "ResourceCollection": json!({
                "CloudFormation": "",
                "Tags": ""
            })
        }),
        "MaxResults": 0,
        "NextToken": "",
        "AccountId": ""
    });

    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);
}

echo '{
  "Filters": {
    "InsightId": "",
    "EventTimeRange": "",
    "EventClass": "",
    "EventSource": "",
    "DataSource": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": ""
}' |  \
  http POST {{baseUrl}}/events \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": {\n    "InsightId": "",\n    "EventTimeRange": "",\n    "EventClass": "",\n    "EventSource": "",\n    "DataSource": "",\n    "ResourceCollection": {\n      "CloudFormation": "",\n      "Tags": ""\n    }\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "AccountId": ""\n}' \
  --output-document \
  - {{baseUrl}}/events

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    "InsightId": "",
    "EventTimeRange": "",
    "EventClass": "",
    "EventSource": "",
    "DataSource": "",
    "ResourceCollection": [
      "CloudFormation": "",
      "Tags": ""
    ]
  ],
  "MaxResults": 0,
  "NextToken": "",
  "AccountId": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/insights");

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  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/insights" {:content-type :json
                                                     :form-params {:StatusFilter {:Ongoing ""
                                                                                  :Closed ""
                                                                                  :Any ""}
                                                                   :MaxResults 0
                                                                   :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/insights"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\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}}/insights"),
    Content = new StringContent("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\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}}/insights");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\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}}/insights"

	payload := strings.NewReader("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\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/insights HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/insights")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/insights")
  .header("content-type", "application/json")
  .body("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StatusFilter: {
    Ongoing: '',
    Closed: '',
    Any: ''
  },
  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}}/insights');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/insights',
  headers: {'content-type': 'application/json'},
  data: {StatusFilter: {Ongoing: '', Closed: '', Any: ''}, MaxResults: 0, NextToken: ''}
};

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

const url = '{{baseUrl}}/insights';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatusFilter":{"Ongoing":"","Closed":"","Any":""},"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}}/insights',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StatusFilter": {\n    "Ongoing": "",\n    "Closed": "",\n    "Any": ""\n  },\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  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/insights")
  .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/insights',
  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({StatusFilter: {Ongoing: '', Closed: '', Any: ''}, MaxResults: 0, NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/insights',
  headers: {'content-type': 'application/json'},
  body: {StatusFilter: {Ongoing: '', Closed: '', Any: ''}, 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}}/insights');

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

req.type('json');
req.send({
  StatusFilter: {
    Ongoing: '',
    Closed: '',
    Any: ''
  },
  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}}/insights',
  headers: {'content-type': 'application/json'},
  data: {StatusFilter: {Ongoing: '', Closed: '', Any: ''}, 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}}/insights';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatusFilter":{"Ongoing":"","Closed":"","Any":""},"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 = @{ @"StatusFilter": @{ @"Ongoing": @"", @"Closed": @"", @"Any": @"" },
                              @"MaxResults": @0,
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/insights"]
                                                       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}}/insights" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/insights",
  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([
    'StatusFilter' => [
        'Ongoing' => '',
        'Closed' => '',
        'Any' => ''
    ],
    '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}}/insights', [
  'body' => '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StatusFilter' => [
    'Ongoing' => '',
    'Closed' => '',
    'Any' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));

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

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

append(json_encode([
  'StatusFilter' => [
    'Ongoing' => '',
    'Closed' => '',
    'Any' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/insights');
$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}}/insights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/insights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/insights"

payload = {
    "StatusFilter": {
        "Ongoing": "",
        "Closed": "",
        "Any": ""
    },
    "MaxResults": 0,
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/insights"

payload <- "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\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}}/insights")

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  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\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/insights') do |req|
  req.body = "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\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}}/insights";

    let payload = json!({
        "StatusFilter": json!({
            "Ongoing": "",
            "Closed": "",
            "Any": ""
        }),
        "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);
}

echo '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/insights \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "StatusFilter": {\n    "Ongoing": "",\n    "Closed": "",\n    "Any": ""\n  },\n  "MaxResults": 0,\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/insights

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "StatusFilter": [
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  ],
  "MaxResults": 0,
  "NextToken": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/monitoredResources");

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  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/monitoredResources" {:content-type :json
                                                               :form-params {:Filters {:ResourcePermission ""
                                                                                       :ResourceTypeFilters ""}
                                                                             :MaxResults 0
                                                                             :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/monitoredResources"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\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}}/monitoredResources"),
    Content = new StringContent("{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\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}}/monitoredResources");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\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}}/monitoredResources"

	payload := strings.NewReader("{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\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/monitoredResources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 120

{
  "Filters": {
    "ResourcePermission": "",
    "ResourceTypeFilters": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/monitoredResources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/monitoredResources")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: {
    ResourcePermission: '',
    ResourceTypeFilters: ''
  },
  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}}/monitoredResources');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/monitoredResources',
  headers: {'content-type': 'application/json'},
  data: {
    Filters: {ResourcePermission: '', ResourceTypeFilters: ''},
    MaxResults: 0,
    NextToken: ''
  }
};

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

const url = '{{baseUrl}}/monitoredResources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":{"ResourcePermission":"","ResourceTypeFilters":""},"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}}/monitoredResources',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": {\n    "ResourcePermission": "",\n    "ResourceTypeFilters": ""\n  },\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  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/monitoredResources")
  .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/monitoredResources',
  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({
  Filters: {ResourcePermission: '', ResourceTypeFilters: ''},
  MaxResults: 0,
  NextToken: ''
}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Filters: {
    ResourcePermission: '',
    ResourceTypeFilters: ''
  },
  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}}/monitoredResources',
  headers: {'content-type': 'application/json'},
  data: {
    Filters: {ResourcePermission: '', ResourceTypeFilters: ''},
    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}}/monitoredResources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":{"ResourcePermission":"","ResourceTypeFilters":""},"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 = @{ @"Filters": @{ @"ResourcePermission": @"", @"ResourceTypeFilters": @"" },
                              @"MaxResults": @0,
                              @"NextToken": @"" };

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

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

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

 "{{baseUrl}}/monitoredResources",
  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([
    'Filters' => [
        'ResourcePermission' => '',
        'ResourceTypeFilters' => ''
    ],
    '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}}/monitoredResources', [
  'body' => '{
  "Filters": {
    "ResourcePermission": "",
    "ResourceTypeFilters": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    'ResourcePermission' => '',
    'ResourceTypeFilters' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));

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

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

append(json_encode([
  'Filters' => [
    'ResourcePermission' => '',
    'ResourceTypeFilters' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/monitoredResources');
$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}}/monitoredResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": {
    "ResourcePermission": "",
    "ResourceTypeFilters": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/monitoredResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": {
    "ResourcePermission": "",
    "ResourceTypeFilters": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/monitoredResources"

payload = {
    "Filters": {
        "ResourcePermission": "",
        "ResourceTypeFilters": ""
    },
    "MaxResults": 0,
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/monitoredResources"

payload <- "{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\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}}/monitoredResources")

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  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\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/monitoredResources') do |req|
  req.body = "{\n  \"Filters\": {\n    \"ResourcePermission\": \"\",\n    \"ResourceTypeFilters\": \"\"\n  },\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}}/monitoredResources";

    let payload = json!({
        "Filters": json!({
            "ResourcePermission": "",
            "ResourceTypeFilters": ""
        }),
        "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);
}

echo '{
  "Filters": {
    "ResourcePermission": "",
    "ResourceTypeFilters": ""
  },
  "MaxResults": 0,
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/monitoredResources \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": {\n    "ResourcePermission": "",\n    "ResourceTypeFilters": ""\n  },\n  "MaxResults": 0,\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/monitoredResources

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    "ResourcePermission": "",
    "ResourceTypeFilters": ""
  ],
  "MaxResults": 0,
  "NextToken": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels");

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  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/channels" {:content-type :json
                                                     :form-params {:NextToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/channels"

	payload := strings.NewReader("{\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/channels HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "NextToken": ""
}

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

client.close();

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

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

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

const data = JSON.stringify({
  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}}/channels');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/channels',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\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  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/channels")
  .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/channels',
  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({NextToken: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  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}}/channels',
  headers: {'content-type': 'application/json'},
  data: {NextToken: ''}
};

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

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

const url = '{{baseUrl}}/channels';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"NextToken": @"" };

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

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

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

 "{{baseUrl}}/channels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'NextToken' => ''
  ]),
  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}}/channels', [
  'body' => '{
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/channels');
$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}}/channels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": ""
}'

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

import http.client

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

payload = "{\n  \"NextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/channels"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels"

payload <- "{\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}}/channels")

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  \"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/channels') do |req|
  req.body = "{\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}}/channels";

    let payload = json!({"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);
}

echo '{
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/channels \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/channels

import Foundation

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

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organization/insights");

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  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/organization/insights" {:content-type :json
                                                                  :form-params {:StatusFilter {:Ongoing ""
                                                                                               :Closed ""
                                                                                               :Any ""}
                                                                                :MaxResults 0
                                                                                :AccountIds []
                                                                                :OrganizationalUnitIds []
                                                                                :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/organization/insights"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\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}}/organization/insights"),
    Content = new StringContent("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\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}}/organization/insights");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organization/insights"

	payload := strings.NewReader("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\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/organization/insights HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 167

{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organization/insights")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organization/insights"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\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  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/organization/insights")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/organization/insights")
  .header("content-type", "application/json")
  .body("{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StatusFilter: {
    Ongoing: '',
    Closed: '',
    Any: ''
  },
  MaxResults: 0,
  AccountIds: [],
  OrganizationalUnitIds: [],
  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}}/organization/insights');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/insights',
  headers: {'content-type': 'application/json'},
  data: {
    StatusFilter: {Ongoing: '', Closed: '', Any: ''},
    MaxResults: 0,
    AccountIds: [],
    OrganizationalUnitIds: [],
    NextToken: ''
  }
};

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

const url = '{{baseUrl}}/organization/insights';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatusFilter":{"Ongoing":"","Closed":"","Any":""},"MaxResults":0,"AccountIds":[],"OrganizationalUnitIds":[],"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}}/organization/insights',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StatusFilter": {\n    "Ongoing": "",\n    "Closed": "",\n    "Any": ""\n  },\n  "MaxResults": 0,\n  "AccountIds": [],\n  "OrganizationalUnitIds": [],\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  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organization/insights")
  .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/organization/insights',
  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({
  StatusFilter: {Ongoing: '', Closed: '', Any: ''},
  MaxResults: 0,
  AccountIds: [],
  OrganizationalUnitIds: [],
  NextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/insights',
  headers: {'content-type': 'application/json'},
  body: {
    StatusFilter: {Ongoing: '', Closed: '', Any: ''},
    MaxResults: 0,
    AccountIds: [],
    OrganizationalUnitIds: [],
    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}}/organization/insights');

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

req.type('json');
req.send({
  StatusFilter: {
    Ongoing: '',
    Closed: '',
    Any: ''
  },
  MaxResults: 0,
  AccountIds: [],
  OrganizationalUnitIds: [],
  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}}/organization/insights',
  headers: {'content-type': 'application/json'},
  data: {
    StatusFilter: {Ongoing: '', Closed: '', Any: ''},
    MaxResults: 0,
    AccountIds: [],
    OrganizationalUnitIds: [],
    NextToken: ''
  }
};

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

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

const url = '{{baseUrl}}/organization/insights';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatusFilter":{"Ongoing":"","Closed":"","Any":""},"MaxResults":0,"AccountIds":[],"OrganizationalUnitIds":[],"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 = @{ @"StatusFilter": @{ @"Ongoing": @"", @"Closed": @"", @"Any": @"" },
                              @"MaxResults": @0,
                              @"AccountIds": @[  ],
                              @"OrganizationalUnitIds": @[  ],
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organization/insights"]
                                                       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}}/organization/insights" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/organization/insights",
  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([
    'StatusFilter' => [
        'Ongoing' => '',
        'Closed' => '',
        'Any' => ''
    ],
    'MaxResults' => 0,
    'AccountIds' => [
        
    ],
    'OrganizationalUnitIds' => [
        
    ],
    '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}}/organization/insights', [
  'body' => '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organization/insights');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StatusFilter' => [
    'Ongoing' => '',
    'Closed' => '',
    'Any' => ''
  ],
  'MaxResults' => 0,
  'AccountIds' => [
    
  ],
  'OrganizationalUnitIds' => [
    
  ],
  'NextToken' => ''
]));

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

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

append(json_encode([
  'StatusFilter' => [
    'Ongoing' => '',
    'Closed' => '',
    'Any' => ''
  ],
  'MaxResults' => 0,
  'AccountIds' => [
    
  ],
  'OrganizationalUnitIds' => [
    
  ],
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/organization/insights');
$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}}/organization/insights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organization/insights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\n  \"NextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/organization/insights"

payload = {
    "StatusFilter": {
        "Ongoing": "",
        "Closed": "",
        "Any": ""
    },
    "MaxResults": 0,
    "AccountIds": [],
    "OrganizationalUnitIds": [],
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organization/insights"

payload <- "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\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}}/organization/insights")

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  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\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/organization/insights') do |req|
  req.body = "{\n  \"StatusFilter\": {\n    \"Ongoing\": \"\",\n    \"Closed\": \"\",\n    \"Any\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"AccountIds\": [],\n  \"OrganizationalUnitIds\": [],\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}}/organization/insights";

    let payload = json!({
        "StatusFilter": json!({
            "Ongoing": "",
            "Closed": "",
            "Any": ""
        }),
        "MaxResults": 0,
        "AccountIds": (),
        "OrganizationalUnitIds": (),
        "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);
}

echo '{
  "StatusFilter": {
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  },
  "MaxResults": 0,
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/organization/insights \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "StatusFilter": {\n    "Ongoing": "",\n    "Closed": "",\n    "Any": ""\n  },\n  "MaxResults": 0,\n  "AccountIds": [],\n  "OrganizationalUnitIds": [],\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/organization/insights

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "StatusFilter": [
    "Ongoing": "",
    "Closed": "",
    "Any": ""
  ],
  "MaxResults": 0,
  "AccountIds": [],
  "OrganizationalUnitIds": [],
  "NextToken": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/recommendations");

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  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/recommendations" {:content-type :json
                                                            :form-params {:InsightId ""
                                                                          :NextToken ""
                                                                          :Locale ""
                                                                          :AccountId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/recommendations"

	payload := strings.NewReader("{\n  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\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/recommendations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 75

{
  "InsightId": "",
  "NextToken": "",
  "Locale": "",
  "AccountId": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/recommendations")
  .header("content-type", "application/json")
  .body("{\n  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InsightId: '',
  NextToken: '',
  Locale: '',
  AccountId: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/recommendations',
  headers: {'content-type': 'application/json'},
  data: {InsightId: '', NextToken: '', Locale: '', AccountId: ''}
};

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

const url = '{{baseUrl}}/recommendations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InsightId":"","NextToken":"","Locale":"","AccountId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/recommendations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InsightId": "",\n  "NextToken": "",\n  "Locale": "",\n  "AccountId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/recommendations")
  .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/recommendations',
  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({InsightId: '', NextToken: '', Locale: '', AccountId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/recommendations',
  headers: {'content-type': 'application/json'},
  body: {InsightId: '', NextToken: '', Locale: '', AccountId: ''},
  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}}/recommendations');

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

req.type('json');
req.send({
  InsightId: '',
  NextToken: '',
  Locale: '',
  AccountId: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/recommendations',
  headers: {'content-type': 'application/json'},
  data: {InsightId: '', NextToken: '', Locale: '', AccountId: ''}
};

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

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

const url = '{{baseUrl}}/recommendations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InsightId":"","NextToken":"","Locale":"","AccountId":""}'
};

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 = @{ @"InsightId": @"",
                              @"NextToken": @"",
                              @"Locale": @"",
                              @"AccountId": @"" };

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

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

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

 "{{baseUrl}}/recommendations",
  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([
    'InsightId' => '',
    'NextToken' => '',
    'Locale' => '',
    'AccountId' => ''
  ]),
  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}}/recommendations', [
  'body' => '{
  "InsightId": "",
  "NextToken": "",
  "Locale": "",
  "AccountId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InsightId' => '',
  'NextToken' => '',
  'Locale' => '',
  'AccountId' => ''
]));

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

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

append(json_encode([
  'InsightId' => '',
  'NextToken' => '',
  'Locale' => '',
  'AccountId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/recommendations');
$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}}/recommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InsightId": "",
  "NextToken": "",
  "Locale": "",
  "AccountId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/recommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InsightId": "",
  "NextToken": "",
  "Locale": "",
  "AccountId": ""
}'

import http.client

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

payload = "{\n  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/recommendations"

payload = {
    "InsightId": "",
    "NextToken": "",
    "Locale": "",
    "AccountId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/recommendations"

payload <- "{\n  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\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}}/recommendations")

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  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\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/recommendations') do |req|
  req.body = "{\n  \"InsightId\": \"\",\n  \"NextToken\": \"\",\n  \"Locale\": \"\",\n  \"AccountId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "InsightId": "",
        "NextToken": "",
        "Locale": "",
        "AccountId": ""
    });

    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);
}

echo '{
  "InsightId": "",
  "NextToken": "",
  "Locale": "",
  "AccountId": ""
}' |  \
  http POST {{baseUrl}}/recommendations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InsightId": "",\n  "NextToken": "",\n  "Locale": "",\n  "AccountId": ""\n}' \
  --output-document \
  - {{baseUrl}}/recommendations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "InsightId": "",
  "NextToken": "",
  "Locale": "",
  "AccountId": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/feedback");

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  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/feedback" {:content-type :json
                                                    :form-params {:InsightFeedback {:Id ""
                                                                                    :Feedback ""}}})

require "http/client"

url = "{{baseUrl}}/feedback"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/feedback"),
    Content = new StringContent("{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\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}}/feedback");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/feedback"

	payload := strings.NewReader("{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", 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))

}

PUT /baseUrl/feedback HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "InsightFeedback": {
    "Id": "",
    "Feedback": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/feedback")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/feedback"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\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  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/feedback")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/feedback")
  .header("content-type", "application/json")
  .body("{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  InsightFeedback: {
    Id: '',
    Feedback: ''
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/feedback');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/feedback',
  headers: {'content-type': 'application/json'},
  data: {InsightFeedback: {Id: '', Feedback: ''}}
};

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

const url = '{{baseUrl}}/feedback';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"InsightFeedback":{"Id":"","Feedback":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/feedback',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InsightFeedback": {\n    "Id": "",\n    "Feedback": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/feedback")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/feedback',
  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({InsightFeedback: {Id: '', Feedback: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/feedback',
  headers: {'content-type': 'application/json'},
  body: {InsightFeedback: {Id: '', Feedback: ''}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/feedback');

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

req.type('json');
req.send({
  InsightFeedback: {
    Id: '',
    Feedback: ''
  }
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/feedback',
  headers: {'content-type': 'application/json'},
  data: {InsightFeedback: {Id: '', Feedback: ''}}
};

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

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

const url = '{{baseUrl}}/feedback';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"InsightFeedback":{"Id":"","Feedback":""}}'
};

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 = @{ @"InsightFeedback": @{ @"Id": @"", @"Feedback": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/feedback"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/feedback" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/feedback",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'InsightFeedback' => [
        'Id' => '',
        'Feedback' => ''
    ]
  ]),
  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('PUT', '{{baseUrl}}/feedback', [
  'body' => '{
  "InsightFeedback": {
    "Id": "",
    "Feedback": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/feedback');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InsightFeedback' => [
    'Id' => '',
    'Feedback' => ''
  ]
]));

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

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

append(json_encode([
  'InsightFeedback' => [
    'Id' => '',
    'Feedback' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/feedback');
$request->setRequestMethod('PUT');
$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}}/feedback' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "InsightFeedback": {
    "Id": "",
    "Feedback": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/feedback' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "InsightFeedback": {
    "Id": "",
    "Feedback": ""
  }
}'

import http.client

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

payload = "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/feedback", payload, headers)

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

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

import requests

url = "{{baseUrl}}/feedback"

payload = { "InsightFeedback": {
        "Id": "",
        "Feedback": ""
    } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/feedback"

payload <- "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/feedback")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\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.put('/baseUrl/feedback') do |req|
  req.body = "{\n  \"InsightFeedback\": {\n    \"Id\": \"\",\n    \"Feedback\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({"InsightFeedback": json!({
            "Id": "",
            "Feedback": ""
        })});

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "InsightFeedback": {
    "Id": "",
    "Feedback": ""
  }
}' |  \
  http PUT {{baseUrl}}/feedback \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "InsightFeedback": {\n    "Id": "",\n    "Feedback": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/feedback

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["InsightFeedback": [
    "Id": "",
    "Feedback": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/feedback")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels/:Id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/channels/:Id")

require "http/client"

url = "{{baseUrl}}/channels/:Id"

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}}/channels/:Id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:Id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/channels/:Id"

	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/channels/:Id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/channels/:Id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:Id"))
    .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}}/channels/:Id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/channels/:Id")
  .asString();

const 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}}/channels/:Id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/channels/:Id'};

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

const url = '{{baseUrl}}/channels/:Id';
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}}/channels/:Id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:Id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:Id',
  headers: {}
};

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

  res.on('data', function (chunk) {
    chunks.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}}/channels/:Id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/channels/:Id');

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}}/channels/:Id'};

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

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

const url = '{{baseUrl}}/channels/:Id';
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}}/channels/:Id"]
                                                       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}}/channels/:Id" in

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

 "{{baseUrl}}/channels/:Id",
  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}}/channels/:Id');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:Id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/channels/:Id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:Id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:Id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/channels/:Id")

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

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

import requests

url = "{{baseUrl}}/channels/:Id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:Id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:Id")

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/channels/:Id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/channels/:Id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/channels/:Id

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/insights/search");

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  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/insights/search" {:content-type :json
                                                            :form-params {:StartTimeRange {:FromTime ""
                                                                                           :ToTime ""}
                                                                          :Filters {:Severities ""
                                                                                    :Statuses ""
                                                                                    :ResourceCollection {:CloudFormation ""
                                                                                                         :Tags ""}
                                                                                    :ServiceCollection ""}
                                                                          :MaxResults 0
                                                                          :NextToken ""
                                                                          :Type ""}})

require "http/client"

url = "{{baseUrl}}/insights/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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}}/insights/search"),
    Content = new StringContent("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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}}/insights/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/insights/search"

	payload := strings.NewReader("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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/insights/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 288

{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/insights/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/insights/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/insights/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/insights/search")
  .header("content-type", "application/json")
  .body("{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StartTimeRange: {
    FromTime: '',
    ToTime: ''
  },
  Filters: {
    Severities: '',
    Statuses: '',
    ResourceCollection: {
      CloudFormation: '',
      Tags: ''
    },
    ServiceCollection: ''
  },
  MaxResults: 0,
  NextToken: '',
  Type: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/insights/search',
  headers: {'content-type': 'application/json'},
  data: {
    StartTimeRange: {FromTime: '', ToTime: ''},
    Filters: {
      Severities: '',
      Statuses: '',
      ResourceCollection: {CloudFormation: '', Tags: ''},
      ServiceCollection: ''
    },
    MaxResults: 0,
    NextToken: '',
    Type: ''
  }
};

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

const url = '{{baseUrl}}/insights/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StartTimeRange":{"FromTime":"","ToTime":""},"Filters":{"Severities":"","Statuses":"","ResourceCollection":{"CloudFormation":"","Tags":""},"ServiceCollection":""},"MaxResults":0,"NextToken":"","Type":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/insights/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StartTimeRange": {\n    "FromTime": "",\n    "ToTime": ""\n  },\n  "Filters": {\n    "Severities": "",\n    "Statuses": "",\n    "ResourceCollection": {\n      "CloudFormation": "",\n      "Tags": ""\n    },\n    "ServiceCollection": ""\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "Type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/insights/search")
  .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/insights/search',
  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({
  StartTimeRange: {FromTime: '', ToTime: ''},
  Filters: {
    Severities: '',
    Statuses: '',
    ResourceCollection: {CloudFormation: '', Tags: ''},
    ServiceCollection: ''
  },
  MaxResults: 0,
  NextToken: '',
  Type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/insights/search',
  headers: {'content-type': 'application/json'},
  body: {
    StartTimeRange: {FromTime: '', ToTime: ''},
    Filters: {
      Severities: '',
      Statuses: '',
      ResourceCollection: {CloudFormation: '', Tags: ''},
      ServiceCollection: ''
    },
    MaxResults: 0,
    NextToken: '',
    Type: ''
  },
  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}}/insights/search');

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

req.type('json');
req.send({
  StartTimeRange: {
    FromTime: '',
    ToTime: ''
  },
  Filters: {
    Severities: '',
    Statuses: '',
    ResourceCollection: {
      CloudFormation: '',
      Tags: ''
    },
    ServiceCollection: ''
  },
  MaxResults: 0,
  NextToken: '',
  Type: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/insights/search',
  headers: {'content-type': 'application/json'},
  data: {
    StartTimeRange: {FromTime: '', ToTime: ''},
    Filters: {
      Severities: '',
      Statuses: '',
      ResourceCollection: {CloudFormation: '', Tags: ''},
      ServiceCollection: ''
    },
    MaxResults: 0,
    NextToken: '',
    Type: ''
  }
};

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

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

const url = '{{baseUrl}}/insights/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StartTimeRange":{"FromTime":"","ToTime":""},"Filters":{"Severities":"","Statuses":"","ResourceCollection":{"CloudFormation":"","Tags":""},"ServiceCollection":""},"MaxResults":0,"NextToken":"","Type":""}'
};

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 = @{ @"StartTimeRange": @{ @"FromTime": @"", @"ToTime": @"" },
                              @"Filters": @{ @"Severities": @"", @"Statuses": @"", @"ResourceCollection": @{ @"CloudFormation": @"", @"Tags": @"" }, @"ServiceCollection": @"" },
                              @"MaxResults": @0,
                              @"NextToken": @"",
                              @"Type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/insights/search"]
                                                       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}}/insights/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}" in

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

 "{{baseUrl}}/insights/search",
  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([
    'StartTimeRange' => [
        'FromTime' => '',
        'ToTime' => ''
    ],
    'Filters' => [
        'Severities' => '',
        'Statuses' => '',
        'ResourceCollection' => [
                'CloudFormation' => '',
                'Tags' => ''
        ],
        'ServiceCollection' => ''
    ],
    'MaxResults' => 0,
    'NextToken' => '',
    'Type' => ''
  ]),
  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}}/insights/search', [
  'body' => '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/insights/search');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StartTimeRange' => [
    'FromTime' => '',
    'ToTime' => ''
  ],
  'Filters' => [
    'Severities' => '',
    'Statuses' => '',
    'ResourceCollection' => [
        'CloudFormation' => '',
        'Tags' => ''
    ],
    'ServiceCollection' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'Type' => ''
]));

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

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

append(json_encode([
  'StartTimeRange' => [
    'FromTime' => '',
    'ToTime' => ''
  ],
  'Filters' => [
    'Severities' => '',
    'Statuses' => '',
    'ResourceCollection' => [
        'CloudFormation' => '',
        'Tags' => ''
    ],
    'ServiceCollection' => ''
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'Type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/insights/search');
$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}}/insights/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/insights/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}'

import http.client

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

payload = "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/insights/search"

payload = {
    "StartTimeRange": {
        "FromTime": "",
        "ToTime": ""
    },
    "Filters": {
        "Severities": "",
        "Statuses": "",
        "ResourceCollection": {
            "CloudFormation": "",
            "Tags": ""
        },
        "ServiceCollection": ""
    },
    "MaxResults": 0,
    "NextToken": "",
    "Type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/insights/search"

payload <- "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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}}/insights/search")

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  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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/insights/search') do |req|
  req.body = "{\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": \"\"\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "StartTimeRange": json!({
            "FromTime": "",
            "ToTime": ""
        }),
        "Filters": json!({
            "Severities": "",
            "Statuses": "",
            "ResourceCollection": json!({
                "CloudFormation": "",
                "Tags": ""
            }),
            "ServiceCollection": ""
        }),
        "MaxResults": 0,
        "NextToken": "",
        "Type": ""
    });

    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);
}

echo '{
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": ""
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}' |  \
  http POST {{baseUrl}}/insights/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "StartTimeRange": {\n    "FromTime": "",\n    "ToTime": ""\n  },\n  "Filters": {\n    "Severities": "",\n    "Statuses": "",\n    "ResourceCollection": {\n      "CloudFormation": "",\n      "Tags": ""\n    },\n    "ServiceCollection": ""\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "Type": ""\n}' \
  --output-document \
  - {{baseUrl}}/insights/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "StartTimeRange": [
    "FromTime": "",
    "ToTime": ""
  ],
  "Filters": [
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": [
      "CloudFormation": "",
      "Tags": ""
    ],
    "ServiceCollection": ""
  ],
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/organization/insights/search");

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  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/organization/insights/search" {:content-type :json
                                                                         :form-params {:AccountIds []
                                                                                       :StartTimeRange {:FromTime ""
                                                                                                        :ToTime ""}
                                                                                       :Filters {:Severities ""
                                                                                                 :Statuses ""
                                                                                                 :ResourceCollection {:CloudFormation ""
                                                                                                                      :Tags ""}
                                                                                                 :ServiceCollection {:ServiceNames ""}}
                                                                                       :MaxResults 0
                                                                                       :NextToken ""
                                                                                       :Type ""}})

require "http/client"

url = "{{baseUrl}}/organization/insights/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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}}/organization/insights/search"),
    Content = new StringContent("{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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}}/organization/insights/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/organization/insights/search"

	payload := strings.NewReader("{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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/organization/insights/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 338

{
  "AccountIds": [],
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": {
      "ServiceNames": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/organization/insights/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/organization/insights/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/organization/insights/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/organization/insights/search")
  .header("content-type", "application/json")
  .body("{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccountIds: [],
  StartTimeRange: {
    FromTime: '',
    ToTime: ''
  },
  Filters: {
    Severities: '',
    Statuses: '',
    ResourceCollection: {
      CloudFormation: '',
      Tags: ''
    },
    ServiceCollection: {
      ServiceNames: ''
    }
  },
  MaxResults: 0,
  NextToken: '',
  Type: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/organization/insights/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/insights/search',
  headers: {'content-type': 'application/json'},
  data: {
    AccountIds: [],
    StartTimeRange: {FromTime: '', ToTime: ''},
    Filters: {
      Severities: '',
      Statuses: '',
      ResourceCollection: {CloudFormation: '', Tags: ''},
      ServiceCollection: {ServiceNames: ''}
    },
    MaxResults: 0,
    NextToken: '',
    Type: ''
  }
};

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

const url = '{{baseUrl}}/organization/insights/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountIds":[],"StartTimeRange":{"FromTime":"","ToTime":""},"Filters":{"Severities":"","Statuses":"","ResourceCollection":{"CloudFormation":"","Tags":""},"ServiceCollection":{"ServiceNames":""}},"MaxResults":0,"NextToken":"","Type":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/organization/insights/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccountIds": [],\n  "StartTimeRange": {\n    "FromTime": "",\n    "ToTime": ""\n  },\n  "Filters": {\n    "Severities": "",\n    "Statuses": "",\n    "ResourceCollection": {\n      "CloudFormation": "",\n      "Tags": ""\n    },\n    "ServiceCollection": {\n      "ServiceNames": ""\n    }\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "Type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/organization/insights/search")
  .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/organization/insights/search',
  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({
  AccountIds: [],
  StartTimeRange: {FromTime: '', ToTime: ''},
  Filters: {
    Severities: '',
    Statuses: '',
    ResourceCollection: {CloudFormation: '', Tags: ''},
    ServiceCollection: {ServiceNames: ''}
  },
  MaxResults: 0,
  NextToken: '',
  Type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/insights/search',
  headers: {'content-type': 'application/json'},
  body: {
    AccountIds: [],
    StartTimeRange: {FromTime: '', ToTime: ''},
    Filters: {
      Severities: '',
      Statuses: '',
      ResourceCollection: {CloudFormation: '', Tags: ''},
      ServiceCollection: {ServiceNames: ''}
    },
    MaxResults: 0,
    NextToken: '',
    Type: ''
  },
  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}}/organization/insights/search');

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

req.type('json');
req.send({
  AccountIds: [],
  StartTimeRange: {
    FromTime: '',
    ToTime: ''
  },
  Filters: {
    Severities: '',
    Statuses: '',
    ResourceCollection: {
      CloudFormation: '',
      Tags: ''
    },
    ServiceCollection: {
      ServiceNames: ''
    }
  },
  MaxResults: 0,
  NextToken: '',
  Type: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/organization/insights/search',
  headers: {'content-type': 'application/json'},
  data: {
    AccountIds: [],
    StartTimeRange: {FromTime: '', ToTime: ''},
    Filters: {
      Severities: '',
      Statuses: '',
      ResourceCollection: {CloudFormation: '', Tags: ''},
      ServiceCollection: {ServiceNames: ''}
    },
    MaxResults: 0,
    NextToken: '',
    Type: ''
  }
};

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

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

const url = '{{baseUrl}}/organization/insights/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccountIds":[],"StartTimeRange":{"FromTime":"","ToTime":""},"Filters":{"Severities":"","Statuses":"","ResourceCollection":{"CloudFormation":"","Tags":""},"ServiceCollection":{"ServiceNames":""}},"MaxResults":0,"NextToken":"","Type":""}'
};

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 = @{ @"AccountIds": @[  ],
                              @"StartTimeRange": @{ @"FromTime": @"", @"ToTime": @"" },
                              @"Filters": @{ @"Severities": @"", @"Statuses": @"", @"ResourceCollection": @{ @"CloudFormation": @"", @"Tags": @"" }, @"ServiceCollection": @{ @"ServiceNames": @"" } },
                              @"MaxResults": @0,
                              @"NextToken": @"",
                              @"Type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/organization/insights/search"]
                                                       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}}/organization/insights/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}" in

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

 "{{baseUrl}}/organization/insights/search",
  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([
    'AccountIds' => [
        
    ],
    'StartTimeRange' => [
        'FromTime' => '',
        'ToTime' => ''
    ],
    'Filters' => [
        'Severities' => '',
        'Statuses' => '',
        'ResourceCollection' => [
                'CloudFormation' => '',
                'Tags' => ''
        ],
        'ServiceCollection' => [
                'ServiceNames' => ''
        ]
    ],
    'MaxResults' => 0,
    'NextToken' => '',
    'Type' => ''
  ]),
  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}}/organization/insights/search', [
  'body' => '{
  "AccountIds": [],
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": {
      "ServiceNames": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/organization/insights/search');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccountIds' => [
    
  ],
  'StartTimeRange' => [
    'FromTime' => '',
    'ToTime' => ''
  ],
  'Filters' => [
    'Severities' => '',
    'Statuses' => '',
    'ResourceCollection' => [
        'CloudFormation' => '',
        'Tags' => ''
    ],
    'ServiceCollection' => [
        'ServiceNames' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'Type' => ''
]));

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

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

append(json_encode([
  'AccountIds' => [
    
  ],
  'StartTimeRange' => [
    'FromTime' => '',
    'ToTime' => ''
  ],
  'Filters' => [
    'Severities' => '',
    'Statuses' => '',
    'ResourceCollection' => [
        'CloudFormation' => '',
        'Tags' => ''
    ],
    'ServiceCollection' => [
        'ServiceNames' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => '',
  'Type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/organization/insights/search');
$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}}/organization/insights/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountIds": [],
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": {
      "ServiceNames": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/organization/insights/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountIds": [],
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": {
      "ServiceNames": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}'

import http.client

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

payload = "{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/organization/insights/search"

payload = {
    "AccountIds": [],
    "StartTimeRange": {
        "FromTime": "",
        "ToTime": ""
    },
    "Filters": {
        "Severities": "",
        "Statuses": "",
        "ResourceCollection": {
            "CloudFormation": "",
            "Tags": ""
        },
        "ServiceCollection": { "ServiceNames": "" }
    },
    "MaxResults": 0,
    "NextToken": "",
    "Type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/organization/insights/search"

payload <- "{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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}}/organization/insights/search")

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  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\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/organization/insights/search') do |req|
  req.body = "{\n  \"AccountIds\": [],\n  \"StartTimeRange\": {\n    \"FromTime\": \"\",\n    \"ToTime\": \"\"\n  },\n  \"Filters\": {\n    \"Severities\": \"\",\n    \"Statuses\": \"\",\n    \"ResourceCollection\": {\n      \"CloudFormation\": \"\",\n      \"Tags\": \"\"\n    },\n    \"ServiceCollection\": {\n      \"ServiceNames\": \"\"\n    }\n  },\n  \"MaxResults\": 0,\n  \"NextToken\": \"\",\n  \"Type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "AccountIds": (),
        "StartTimeRange": json!({
            "FromTime": "",
            "ToTime": ""
        }),
        "Filters": json!({
            "Severities": "",
            "Statuses": "",
            "ResourceCollection": json!({
                "CloudFormation": "",
                "Tags": ""
            }),
            "ServiceCollection": json!({"ServiceNames": ""})
        }),
        "MaxResults": 0,
        "NextToken": "",
        "Type": ""
    });

    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);
}

echo '{
  "AccountIds": [],
  "StartTimeRange": {
    "FromTime": "",
    "ToTime": ""
  },
  "Filters": {
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": {
      "CloudFormation": "",
      "Tags": ""
    },
    "ServiceCollection": {
      "ServiceNames": ""
    }
  },
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
}' |  \
  http POST {{baseUrl}}/organization/insights/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccountIds": [],\n  "StartTimeRange": {\n    "FromTime": "",\n    "ToTime": ""\n  },\n  "Filters": {\n    "Severities": "",\n    "Statuses": "",\n    "ResourceCollection": {\n      "CloudFormation": "",\n      "Tags": ""\n    },\n    "ServiceCollection": {\n      "ServiceNames": ""\n    }\n  },\n  "MaxResults": 0,\n  "NextToken": "",\n  "Type": ""\n}' \
  --output-document \
  - {{baseUrl}}/organization/insights/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AccountIds": [],
  "StartTimeRange": [
    "FromTime": "",
    "ToTime": ""
  ],
  "Filters": [
    "Severities": "",
    "Statuses": "",
    "ResourceCollection": [
      "CloudFormation": "",
      "Tags": ""
    ],
    "ServiceCollection": ["ServiceNames": ""]
  ],
  "MaxResults": 0,
  "NextToken": "",
  "Type": ""
] as [String : Any]

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

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cost-estimation");

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  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/cost-estimation" {:content-type :json
                                                           :form-params {:ResourceCollection {:CloudFormation ""
                                                                                              :Tags ""}
                                                                         :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/cost-estimation"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/cost-estimation"),
    Content = new StringContent("{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\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}}/cost-estimation");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/cost-estimation"

	payload := strings.NewReader("{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")

	req, _ := http.NewRequest("PUT", 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))

}

PUT /baseUrl/cost-estimation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 95

{
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  },
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/cost-estimation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cost-estimation"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\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  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/cost-estimation")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/cost-estimation")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceCollection: {
    CloudFormation: '',
    Tags: ''
  },
  ClientToken: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/cost-estimation');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/cost-estimation',
  headers: {'content-type': 'application/json'},
  data: {ResourceCollection: {CloudFormation: '', Tags: ''}, ClientToken: ''}
};

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

const url = '{{baseUrl}}/cost-estimation';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ResourceCollection":{"CloudFormation":"","Tags":""},"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}}/cost-estimation',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceCollection": {\n    "CloudFormation": "",\n    "Tags": ""\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  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/cost-estimation")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/cost-estimation',
  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({ResourceCollection: {CloudFormation: '', Tags: ''}, ClientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/cost-estimation',
  headers: {'content-type': 'application/json'},
  body: {ResourceCollection: {CloudFormation: '', Tags: ''}, 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('PUT', '{{baseUrl}}/cost-estimation');

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

req.type('json');
req.send({
  ResourceCollection: {
    CloudFormation: '',
    Tags: ''
  },
  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: 'PUT',
  url: '{{baseUrl}}/cost-estimation',
  headers: {'content-type': 'application/json'},
  data: {ResourceCollection: {CloudFormation: '', Tags: ''}, ClientToken: ''}
};

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

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

const url = '{{baseUrl}}/cost-estimation';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ResourceCollection":{"CloudFormation":"","Tags":""},"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 = @{ @"ResourceCollection": @{ @"CloudFormation": @"", @"Tags": @"" },
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/cost-estimation"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/cost-estimation" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/cost-estimation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'ResourceCollection' => [
        'CloudFormation' => '',
        'Tags' => ''
    ],
    '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('PUT', '{{baseUrl}}/cost-estimation', [
  'body' => '{
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  },
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/cost-estimation');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceCollection' => [
    'CloudFormation' => '',
    'Tags' => ''
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'ResourceCollection' => [
    'CloudFormation' => '',
    'Tags' => ''
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/cost-estimation');
$request->setRequestMethod('PUT');
$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}}/cost-estimation' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  },
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/cost-estimation' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  },
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/cost-estimation", payload, headers)

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

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

import requests

url = "{{baseUrl}}/cost-estimation"

payload = {
    "ResourceCollection": {
        "CloudFormation": "",
        "Tags": ""
    },
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/cost-estimation"

payload <- "{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/cost-estimation")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\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.put('/baseUrl/cost-estimation') do |req|
  req.body = "{\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ResourceCollection": json!({
            "CloudFormation": "",
            "Tags": ""
        }),
        "ClientToken": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  },
  "ClientToken": ""
}' |  \
  http PUT {{baseUrl}}/cost-estimation \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceCollection": {\n    "CloudFormation": "",\n    "Tags": ""\n  },\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/cost-estimation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ResourceCollection": [
    "CloudFormation": "",
    "Tags": ""
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cost-estimation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event-sources");

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  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/event-sources" {:content-type :json
                                                         :form-params {:EventSources {:AmazonCodeGuruProfiler ""}}})

require "http/client"

url = "{{baseUrl}}/event-sources"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/event-sources"),
    Content = new StringContent("{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\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}}/event-sources");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/event-sources"

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

	req, _ := http.NewRequest("PUT", 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))

}

PUT /baseUrl/event-sources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "EventSources": {
    "AmazonCodeGuruProfiler": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/event-sources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/event-sources"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\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  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/event-sources")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/event-sources")
  .header("content-type", "application/json")
  .body("{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/event-sources');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/event-sources',
  headers: {'content-type': 'application/json'},
  data: {EventSources: {AmazonCodeGuruProfiler: ''}}
};

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

const url = '{{baseUrl}}/event-sources';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"EventSources":{"AmazonCodeGuruProfiler":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/event-sources',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventSources": {\n    "AmazonCodeGuruProfiler": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/event-sources")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/event-sources',
  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({EventSources: {AmazonCodeGuruProfiler: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/event-sources',
  headers: {'content-type': 'application/json'},
  body: {EventSources: {AmazonCodeGuruProfiler: ''}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/event-sources');

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

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/event-sources',
  headers: {'content-type': 'application/json'},
  data: {EventSources: {AmazonCodeGuruProfiler: ''}}
};

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

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

const url = '{{baseUrl}}/event-sources';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"EventSources":{"AmazonCodeGuruProfiler":""}}'
};

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 = @{ @"EventSources": @{ @"AmazonCodeGuruProfiler": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event-sources"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/event-sources" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/event-sources",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'EventSources' => [
        'AmazonCodeGuruProfiler' => ''
    ]
  ]),
  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('PUT', '{{baseUrl}}/event-sources', [
  'body' => '{
  "EventSources": {
    "AmazonCodeGuruProfiler": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/event-sources');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'EventSources' => [
    'AmazonCodeGuruProfiler' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/event-sources');
$request->setRequestMethod('PUT');
$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}}/event-sources' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "EventSources": {
    "AmazonCodeGuruProfiler": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event-sources' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "EventSources": {
    "AmazonCodeGuruProfiler": ""
  }
}'

import http.client

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

payload = "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/event-sources", payload, headers)

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

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

import requests

url = "{{baseUrl}}/event-sources"

payload = { "EventSources": { "AmazonCodeGuruProfiler": "" } }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/event-sources"

payload <- "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/event-sources")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\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.put('/baseUrl/event-sources') do |req|
  req.body = "{\n  \"EventSources\": {\n    \"AmazonCodeGuruProfiler\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({"EventSources": json!({"AmazonCodeGuruProfiler": ""})});

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "EventSources": {
    "AmazonCodeGuruProfiler": ""
  }
}' |  \
  http PUT {{baseUrl}}/event-sources \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventSources": {\n    "AmazonCodeGuruProfiler": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/event-sources

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["EventSources": ["AmazonCodeGuruProfiler": ""]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event-sources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource-collections");

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  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/resource-collections" {:content-type :json
                                                                :form-params {:Action ""
                                                                              :ResourceCollection {:CloudFormation ""
                                                                                                   :Tags ""}}})

require "http/client"

url = "{{baseUrl}}/resource-collections"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/resource-collections"),
    Content = new StringContent("{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\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}}/resource-collections");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource-collections"

	payload := strings.NewReader("{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", 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))

}

PUT /baseUrl/resource-collections HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 90

{
  "Action": "",
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/resource-collections")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource-collections"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\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  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource-collections")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/resource-collections")
  .header("content-type", "application/json")
  .body("{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Action: '',
  ResourceCollection: {
    CloudFormation: '',
    Tags: ''
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/resource-collections');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource-collections',
  headers: {'content-type': 'application/json'},
  data: {Action: '', ResourceCollection: {CloudFormation: '', Tags: ''}}
};

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

const url = '{{baseUrl}}/resource-collections';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Action":"","ResourceCollection":{"CloudFormation":"","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}}/resource-collections',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Action": "",\n  "ResourceCollection": {\n    "CloudFormation": "",\n    "Tags": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource-collections")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource-collections',
  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({Action: '', ResourceCollection: {CloudFormation: '', Tags: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource-collections',
  headers: {'content-type': 'application/json'},
  body: {Action: '', ResourceCollection: {CloudFormation: '', 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('PUT', '{{baseUrl}}/resource-collections');

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

req.type('json');
req.send({
  Action: '',
  ResourceCollection: {
    CloudFormation: '',
    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: 'PUT',
  url: '{{baseUrl}}/resource-collections',
  headers: {'content-type': 'application/json'},
  data: {Action: '', ResourceCollection: {CloudFormation: '', Tags: ''}}
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource-collections';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Action":"","ResourceCollection":{"CloudFormation":"","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 = @{ @"Action": @"",
                              @"ResourceCollection": @{ @"CloudFormation": @"", @"Tags": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource-collections"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/resource-collections" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource-collections",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'Action' => '',
    'ResourceCollection' => [
        'CloudFormation' => '',
        '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('PUT', '{{baseUrl}}/resource-collections', [
  'body' => '{
  "Action": "",
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource-collections');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Action' => '',
  'ResourceCollection' => [
    'CloudFormation' => '',
    'Tags' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Action' => '',
  'ResourceCollection' => [
    'CloudFormation' => '',
    'Tags' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resource-collections');
$request->setRequestMethod('PUT');
$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}}/resource-collections' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Action": "",
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource-collections' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Action": "",
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/resource-collections", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource-collections"

payload = {
    "Action": "",
    "ResourceCollection": {
        "CloudFormation": "",
        "Tags": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource-collections"

payload <- "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource-collections")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\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.put('/baseUrl/resource-collections') do |req|
  req.body = "{\n  \"Action\": \"\",\n  \"ResourceCollection\": {\n    \"CloudFormation\": \"\",\n    \"Tags\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource-collections";

    let payload = json!({
        "Action": "",
        "ResourceCollection": json!({
            "CloudFormation": "",
            "Tags": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Action": "",
  "ResourceCollection": {
    "CloudFormation": "",
    "Tags": ""
  }
}' |  \
  http PUT {{baseUrl}}/resource-collections \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Action": "",\n  "ResourceCollection": {\n    "CloudFormation": "",\n    "Tags": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/resource-collections

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Action": "",
  "ResourceCollection": [
    "CloudFormation": "",
    "Tags": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource-collections")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/service-integrations");

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  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/service-integrations" {:content-type :json
                                                                :form-params {:ServiceIntegration {:OpsCenter {:OptInStatus ""}
                                                                                                   :LogsAnomalyDetection ""}}})

require "http/client"

url = "{{baseUrl}}/service-integrations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/service-integrations"),
    Content = new StringContent("{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\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}}/service-integrations");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/service-integrations"

	payload := strings.NewReader("{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", 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))

}

PUT /baseUrl/service-integrations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 114

{
  "ServiceIntegration": {
    "OpsCenter": {
      "OptInStatus": ""
    },
    "LogsAnomalyDetection": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/service-integrations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/service-integrations"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\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  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/service-integrations")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/service-integrations")
  .header("content-type", "application/json")
  .body("{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  ServiceIntegration: {
    OpsCenter: {
      OptInStatus: ''
    },
    LogsAnomalyDetection: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/service-integrations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/service-integrations',
  headers: {'content-type': 'application/json'},
  data: {ServiceIntegration: {OpsCenter: {OptInStatus: ''}, LogsAnomalyDetection: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/service-integrations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ServiceIntegration":{"OpsCenter":{"OptInStatus":""},"LogsAnomalyDetection":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/service-integrations',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ServiceIntegration": {\n    "OpsCenter": {\n      "OptInStatus": ""\n    },\n    "LogsAnomalyDetection": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/service-integrations")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/service-integrations',
  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({ServiceIntegration: {OpsCenter: {OptInStatus: ''}, LogsAnomalyDetection: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/service-integrations',
  headers: {'content-type': 'application/json'},
  body: {ServiceIntegration: {OpsCenter: {OptInStatus: ''}, LogsAnomalyDetection: ''}},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/service-integrations');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ServiceIntegration: {
    OpsCenter: {
      OptInStatus: ''
    },
    LogsAnomalyDetection: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/service-integrations',
  headers: {'content-type': 'application/json'},
  data: {ServiceIntegration: {OpsCenter: {OptInStatus: ''}, LogsAnomalyDetection: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/service-integrations';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ServiceIntegration":{"OpsCenter":{"OptInStatus":""},"LogsAnomalyDetection":""}}'
};

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 = @{ @"ServiceIntegration": @{ @"OpsCenter": @{ @"OptInStatus": @"" }, @"LogsAnomalyDetection": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/service-integrations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/service-integrations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/service-integrations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'ServiceIntegration' => [
        'OpsCenter' => [
                'OptInStatus' => ''
        ],
        'LogsAnomalyDetection' => ''
    ]
  ]),
  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('PUT', '{{baseUrl}}/service-integrations', [
  'body' => '{
  "ServiceIntegration": {
    "OpsCenter": {
      "OptInStatus": ""
    },
    "LogsAnomalyDetection": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/service-integrations');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ServiceIntegration' => [
    'OpsCenter' => [
        'OptInStatus' => ''
    ],
    'LogsAnomalyDetection' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ServiceIntegration' => [
    'OpsCenter' => [
        'OptInStatus' => ''
    ],
    'LogsAnomalyDetection' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/service-integrations');
$request->setRequestMethod('PUT');
$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}}/service-integrations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ServiceIntegration": {
    "OpsCenter": {
      "OptInStatus": ""
    },
    "LogsAnomalyDetection": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/service-integrations' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ServiceIntegration": {
    "OpsCenter": {
      "OptInStatus": ""
    },
    "LogsAnomalyDetection": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/service-integrations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/service-integrations"

payload = { "ServiceIntegration": {
        "OpsCenter": { "OptInStatus": "" },
        "LogsAnomalyDetection": ""
    } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/service-integrations"

payload <- "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/service-integrations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\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.put('/baseUrl/service-integrations') do |req|
  req.body = "{\n  \"ServiceIntegration\": {\n    \"OpsCenter\": {\n      \"OptInStatus\": \"\"\n    },\n    \"LogsAnomalyDetection\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/service-integrations";

    let payload = json!({"ServiceIntegration": json!({
            "OpsCenter": json!({"OptInStatus": ""}),
            "LogsAnomalyDetection": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ServiceIntegration": {
    "OpsCenter": {
      "OptInStatus": ""
    },
    "LogsAnomalyDetection": ""
  }
}' |  \
  http PUT {{baseUrl}}/service-integrations \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ServiceIntegration": {\n    "OpsCenter": {\n      "OptInStatus": ""\n    },\n    "LogsAnomalyDetection": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/service-integrations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ServiceIntegration": [
    "OpsCenter": ["OptInStatus": ""],
    "LogsAnomalyDetection": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/service-integrations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()