POST Create an Annotation layer (POST)
{{baseUrl}}/annotation_layer/:pk/annotation/
QUERY PARAMS
pk
BODY json
{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk/annotation/");

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  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}");

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

(client/post "{{baseUrl}}/annotation_layer/:pk/annotation/" {:content-type :json
                                                                             :form-params {:end_dttm ""
                                                                                           :json_metadata ""
                                                                                           :long_descr ""
                                                                                           :short_descr ""
                                                                                           :start_dttm ""}})
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk/annotation/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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}}/annotation_layer/:pk/annotation/"),
    Content = new StringContent("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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}}/annotation_layer/:pk/annotation/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk/annotation/"

	payload := strings.NewReader("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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/annotation_layer/:pk/annotation/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/annotation_layer/:pk/annotation/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/annotation_layer/:pk/annotation/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/annotation_layer/:pk/annotation/")
  .header("content-type", "application/json")
  .body("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  end_dttm: '',
  json_metadata: '',
  long_descr: '',
  short_descr: '',
  start_dttm: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/annotation_layer/:pk/annotation/');
xhr.setRequestHeader('content-type', 'application/json');

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/',
  headers: {'content-type': 'application/json'},
  data: {
    end_dttm: '',
    json_metadata: '',
    long_descr: '',
    short_descr: '',
    start_dttm: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk/annotation/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"end_dttm":"","json_metadata":"","long_descr":"","short_descr":"","start_dttm":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "end_dttm": "",\n  "json_metadata": "",\n  "long_descr": "",\n  "short_descr": "",\n  "start_dttm": ""\n}'
};

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

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/")
  .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/annotation_layer/:pk/annotation/',
  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({
  end_dttm: '',
  json_metadata: '',
  long_descr: '',
  short_descr: '',
  start_dttm: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/',
  headers: {'content-type': 'application/json'},
  body: {
    end_dttm: '',
    json_metadata: '',
    long_descr: '',
    short_descr: '',
    start_dttm: ''
  },
  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}}/annotation_layer/:pk/annotation/');

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

req.type('json');
req.send({
  end_dttm: '',
  json_metadata: '',
  long_descr: '',
  short_descr: '',
  start_dttm: ''
});

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}}/annotation_layer/:pk/annotation/',
  headers: {'content-type': 'application/json'},
  data: {
    end_dttm: '',
    json_metadata: '',
    long_descr: '',
    short_descr: '',
    start_dttm: ''
  }
};

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

const url = '{{baseUrl}}/annotation_layer/:pk/annotation/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"end_dttm":"","json_metadata":"","long_descr":"","short_descr":"","start_dttm":""}'
};

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 = @{ @"end_dttm": @"",
                              @"json_metadata": @"",
                              @"long_descr": @"",
                              @"short_descr": @"",
                              @"start_dttm": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/annotation_layer/:pk/annotation/"]
                                                       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}}/annotation_layer/:pk/annotation/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk/annotation/",
  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([
    'end_dttm' => '',
    'json_metadata' => '',
    'long_descr' => '',
    'short_descr' => '',
    'start_dttm' => ''
  ]),
  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}}/annotation_layer/:pk/annotation/', [
  'body' => '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk/annotation/');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'end_dttm' => '',
  'json_metadata' => '',
  'long_descr' => '',
  'short_descr' => '',
  'start_dttm' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'end_dttm' => '',
  'json_metadata' => '',
  'long_descr' => '',
  'short_descr' => '',
  'start_dttm' => ''
]));
$request->setRequestUrl('{{baseUrl}}/annotation_layer/:pk/annotation/');
$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}}/annotation_layer/:pk/annotation/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}'
import http.client

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

payload = "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}"

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

conn.request("POST", "/baseUrl/annotation_layer/:pk/annotation/", payload, headers)

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

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

url = "{{baseUrl}}/annotation_layer/:pk/annotation/"

payload = {
    "end_dttm": "",
    "json_metadata": "",
    "long_descr": "",
    "short_descr": "",
    "start_dttm": ""
}
headers = {"content-type": "application/json"}

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

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

url <- "{{baseUrl}}/annotation_layer/:pk/annotation/"

payload <- "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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}}/annotation_layer/:pk/annotation/")

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  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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/annotation_layer/:pk/annotation/') do |req|
  req.body = "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "end_dttm": "",
        "json_metadata": "",
        "long_descr": "",
        "short_descr": "",
        "start_dttm": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/annotation_layer/:pk/annotation/ \
  --header 'content-type: application/json' \
  --data '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}'
echo '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}' |  \
  http POST {{baseUrl}}/annotation_layer/:pk/annotation/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "end_dttm": "",\n  "json_metadata": "",\n  "long_descr": "",\n  "short_descr": "",\n  "start_dttm": ""\n}' \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk/annotation/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk/annotation/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()
POST Create an Annotation layer
{{baseUrl}}/annotation_layer/
BODY json
{
  "descr": "",
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

(client/post "{{baseUrl}}/annotation_layer/" {:content-type :json
                                                              :form-params {:descr ""
                                                                            :name ""}})
require "http/client"

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

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

func main() {

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

	payload := strings.NewReader("{\n  \"descr\": \"\",\n  \"name\": \"\"\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/annotation_layer/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/annotation_layer/")
  .header("content-type", "application/json")
  .body("{\n  \"descr\": \"\",\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  descr: '',
  name: ''
});

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

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

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

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"descr":"","name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/annotation_layer/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "descr": "",\n  "name": ""\n}'
};

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

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

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

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

req.type('json');
req.send({
  descr: '',
  name: ''
});

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}}/annotation_layer/',
  headers: {'content-type': 'application/json'},
  data: {descr: '', name: ''}
};

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

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

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

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

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/",
  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([
    'descr' => '',
    'name' => ''
  ]),
  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}}/annotation_layer/', [
  'body' => '{
  "descr": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'descr' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/annotation_layer/');
$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}}/annotation_layer/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "descr": "",
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "descr": "",
  "name": ""
}'
import http.client

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

payload = "{\n  \"descr\": \"\",\n  \"name\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/annotation_layer/"

payload = {
    "descr": "",
    "name": ""
}
headers = {"content-type": "application/json"}

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

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

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

payload <- "{\n  \"descr\": \"\",\n  \"name\": \"\"\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}}/annotation_layer/")

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  \"descr\": \"\",\n  \"name\": \"\"\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/annotation_layer/') do |req|
  req.body = "{\n  \"descr\": \"\",\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "descr": "",
        "name": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/annotation_layer/ \
  --header 'content-type: application/json' \
  --data '{
  "descr": "",
  "name": ""
}'
echo '{
  "descr": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/annotation_layer/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "descr": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/annotation_layer/
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()
DELETE Delete Annotation layer (DELETE)
{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
QUERY PARAMS
pk
annotation_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id");

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

(client/delete "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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/annotation_layer/:pk/annotation/:annotation_id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id');

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id',
  method: 'DELETE',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id'
};

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

const url = '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/annotation_layer/:pk/annotation/:annotation_id")

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

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

url = "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"

response = requests.delete(url)

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

url <- "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"

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

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

url = URI("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_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);
}

curl --request DELETE \
  --url {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
http DELETE {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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()
DELETE Delete Annotation layer
{{baseUrl}}/annotation_layer/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk");

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

(client/delete "{{baseUrl}}/annotation_layer/:pk")
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk"

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}}/annotation_layer/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/annotation_layer/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/annotation_layer/:pk")
  .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}}/annotation_layer/:pk');

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

const options = {method: 'DELETE', url: '{{baseUrl}}/annotation_layer/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk';
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}}/annotation_layer/:pk',
  method: 'DELETE',
  headers: {}
};

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

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

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

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/:pk',
  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}}/annotation_layer/:pk'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/annotation_layer/:pk');

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}}/annotation_layer/:pk'};

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

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

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk",
  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}}/annotation_layer/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/annotation_layer/:pk")

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

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

url = "{{baseUrl}}/annotation_layer/:pk"

response = requests.delete(url)

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

url <- "{{baseUrl}}/annotation_layer/:pk"

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

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

url = URI("{{baseUrl}}/annotation_layer/:pk")

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/annotation_layer/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

curl --request DELETE \
  --url {{baseUrl}}/annotation_layer/:pk
http DELETE {{baseUrl}}/annotation_layer/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk")! 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()
DELETE Deletes multiple annotation in a bulk operation.
{{baseUrl}}/annotation_layer/:pk/annotation/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk/annotation/");

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

(client/delete "{{baseUrl}}/annotation_layer/:pk/annotation/")
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk/annotation/"

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}}/annotation_layer/:pk/annotation/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/annotation_layer/:pk/annotation/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk/annotation/"

	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/annotation_layer/:pk/annotation/ HTTP/1.1
Host: example.com


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/annotation_layer/:pk/annotation/")
  .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}}/annotation_layer/:pk/annotation/');

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk/annotation/';
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}}/annotation_layer/:pk/annotation/',
  method: 'DELETE',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/")
  .delete(null)
  .build()

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

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/:pk/annotation/',
  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}}/annotation_layer/:pk/annotation/'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/annotation_layer/:pk/annotation/');

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}}/annotation_layer/:pk/annotation/'
};

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

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

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk/annotation/",
  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}}/annotation_layer/:pk/annotation/');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk/annotation/');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/:pk/annotation/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/annotation_layer/:pk/annotation/")

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

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

url = "{{baseUrl}}/annotation_layer/:pk/annotation/"

response = requests.delete(url)

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

url <- "{{baseUrl}}/annotation_layer/:pk/annotation/"

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

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

url = URI("{{baseUrl}}/annotation_layer/:pk/annotation/")

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/annotation_layer/:pk/annotation/') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

curl --request DELETE \
  --url {{baseUrl}}/annotation_layer/:pk/annotation/
http DELETE {{baseUrl}}/annotation_layer/:pk/annotation/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk/annotation/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk/annotation/")! 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()
DELETE Deletes multiple annotation layers in a bulk operation.
{{baseUrl}}/annotation_layer/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/");

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

(client/delete "{{baseUrl}}/annotation_layer/")
require "http/client"

url = "{{baseUrl}}/annotation_layer/"

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}}/annotation_layer/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/annotation_layer/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

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

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/annotation_layer/")
  .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}}/annotation_layer/');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/';
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}}/annotation_layer/',
  method: 'DELETE',
  headers: {}
};

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

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

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

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/',
  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}}/annotation_layer/'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/annotation_layer/');

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

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

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

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/",
  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}}/annotation_layer/');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/annotation_layer/")

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

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

url = "{{baseUrl}}/annotation_layer/"

response = requests.delete(url)

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

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

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

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

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

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

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

curl --request DELETE \
  --url {{baseUrl}}/annotation_layer/
http DELETE {{baseUrl}}/annotation_layer/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/annotation_layer/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/")! 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()
GET Get a list of Annotation layers, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata. (GET)
{{baseUrl}}/annotation_layer/:pk/annotation/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk/annotation/");

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

(client/get "{{baseUrl}}/annotation_layer/:pk/annotation/")
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk/annotation/"

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}}/annotation_layer/:pk/annotation/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/annotation_layer/:pk/annotation/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk/annotation/"

	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/annotation_layer/:pk/annotation/ HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/annotation_layer/:pk/annotation/"))
    .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}}/annotation_layer/:pk/annotation/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/annotation_layer/:pk/annotation/")
  .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}}/annotation_layer/:pk/annotation/');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk/annotation/';
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}}/annotation_layer/:pk/annotation/',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/:pk/annotation/',
  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}}/annotation_layer/:pk/annotation/'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/annotation_layer/:pk/annotation/');

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}}/annotation_layer/:pk/annotation/'
};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk/annotation/",
  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}}/annotation_layer/:pk/annotation/');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk/annotation/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/:pk/annotation/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/annotation_layer/:pk/annotation/")

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

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

url = "{{baseUrl}}/annotation_layer/:pk/annotation/"

response = requests.get(url)

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

url <- "{{baseUrl}}/annotation_layer/:pk/annotation/"

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

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

url = URI("{{baseUrl}}/annotation_layer/:pk/annotation/")

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/annotation_layer/:pk/annotation/') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/annotation_layer/:pk/annotation/
http GET {{baseUrl}}/annotation_layer/:pk/annotation/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk/annotation/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk/annotation/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Get a list of Annotation layers, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/annotation_layer/
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/annotation_layer/")
require "http/client"

url = "{{baseUrl}}/annotation_layer/"

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

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

func main() {

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

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/annotation_layer/")
  .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}}/annotation_layer/');

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

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

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

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/',
  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}}/annotation_layer/'};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

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

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

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

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/annotation_layer/")

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

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

url = "{{baseUrl}}/annotation_layer/"

response = requests.get(url)

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

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

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

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

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

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

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/annotation_layer/
http GET {{baseUrl}}/annotation_layer/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/annotation_layer/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get an Annotation layer (GET)
{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
QUERY PARAMS
pk
annotation_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id");

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

(client/get "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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/annotation_layer/:pk/annotation/:annotation_id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id'
};

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

const url = '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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}}/annotation_layer/:pk/annotation/:annotation_id');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/annotation_layer/:pk/annotation/:annotation_id")

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

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

url = "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"

response = requests.get(url)

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

url <- "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"

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

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

url = URI("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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/annotation_layer/:pk/annotation/:annotation_id') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
http GET {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_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()
GET Get an Annotation layer
{{baseUrl}}/annotation_layer/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk");

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

(client/get "{{baseUrl}}/annotation_layer/:pk")
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk"

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

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/annotation_layer/:pk")
  .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}}/annotation_layer/:pk');

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

const options = {method: 'GET', url: '{{baseUrl}}/annotation_layer/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk';
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}}/annotation_layer/:pk',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/:pk',
  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}}/annotation_layer/:pk'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/annotation_layer/:pk');

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}}/annotation_layer/:pk'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk",
  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}}/annotation_layer/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/annotation_layer/:pk")

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

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

url = "{{baseUrl}}/annotation_layer/:pk"

response = requests.get(url)

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

url <- "{{baseUrl}}/annotation_layer/:pk"

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

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

url = URI("{{baseUrl}}/annotation_layer/:pk")

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/annotation_layer/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/annotation_layer/:pk
http GET {{baseUrl}}/annotation_layer/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
GET Get metadata information about this API resource
{{baseUrl}}/annotation_layer/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/_info");

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

(client/get "{{baseUrl}}/annotation_layer/_info")
require "http/client"

url = "{{baseUrl}}/annotation_layer/_info"

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

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

func main() {

	url := "{{baseUrl}}/annotation_layer/_info"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/annotation_layer/_info")
  .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}}/annotation_layer/_info');

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

const options = {method: 'GET', url: '{{baseUrl}}/annotation_layer/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/_info';
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}}/annotation_layer/_info',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/_info',
  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}}/annotation_layer/_info'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/annotation_layer/_info');

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}}/annotation_layer/_info'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/_info",
  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}}/annotation_layer/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/_info');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/_info' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/annotation_layer/_info")

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

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

url = "{{baseUrl}}/annotation_layer/_info"

response = requests.get(url)

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

url <- "{{baseUrl}}/annotation_layer/_info"

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

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

url = URI("{{baseUrl}}/annotation_layer/_info")

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/annotation_layer/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/annotation_layer/_info
http GET {{baseUrl}}/annotation_layer/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/annotation_layer/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/_info")! 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()
PUT Update an Annotation layer (PUT)
{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
QUERY PARAMS
pk
annotation_id
BODY json
{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id");

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  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}");

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

(client/put "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id" {:content-type :json
                                                                                          :form-params {:end_dttm ""
                                                                                                        :json_metadata ""
                                                                                                        :long_descr ""
                                                                                                        :short_descr ""
                                                                                                        :start_dttm ""}})
require "http/client"

url = "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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}}/annotation_layer/:pk/annotation/:annotation_id"),
    Content = new StringContent("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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}}/annotation_layer/:pk/annotation/:annotation_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"

	payload := strings.NewReader("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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/annotation_layer/:pk/annotation/:annotation_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")
  .header("content-type", "application/json")
  .body("{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  end_dttm: '',
  json_metadata: '',
  long_descr: '',
  short_descr: '',
  start_dttm: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id');
xhr.setRequestHeader('content-type', 'application/json');

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id',
  headers: {'content-type': 'application/json'},
  data: {
    end_dttm: '',
    json_metadata: '',
    long_descr: '',
    short_descr: '',
    start_dttm: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"end_dttm":"","json_metadata":"","long_descr":"","short_descr":"","start_dttm":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "end_dttm": "",\n  "json_metadata": "",\n  "long_descr": "",\n  "short_descr": "",\n  "start_dttm": ""\n}'
};

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

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")
  .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/annotation_layer/:pk/annotation/:annotation_id',
  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({
  end_dttm: '',
  json_metadata: '',
  long_descr: '',
  short_descr: '',
  start_dttm: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id',
  headers: {'content-type': 'application/json'},
  body: {
    end_dttm: '',
    json_metadata: '',
    long_descr: '',
    short_descr: '',
    start_dttm: ''
  },
  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}}/annotation_layer/:pk/annotation/:annotation_id');

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

req.type('json');
req.send({
  end_dttm: '',
  json_metadata: '',
  long_descr: '',
  short_descr: '',
  start_dttm: ''
});

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}}/annotation_layer/:pk/annotation/:annotation_id',
  headers: {'content-type': 'application/json'},
  data: {
    end_dttm: '',
    json_metadata: '',
    long_descr: '',
    short_descr: '',
    start_dttm: ''
  }
};

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

const url = '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"end_dttm":"","json_metadata":"","long_descr":"","short_descr":"","start_dttm":""}'
};

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 = @{ @"end_dttm": @"",
                              @"json_metadata": @"",
                              @"long_descr": @"",
                              @"short_descr": @"",
                              @"start_dttm": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"]
                                                       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}}/annotation_layer/:pk/annotation/:annotation_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id",
  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([
    'end_dttm' => '',
    'json_metadata' => '',
    'long_descr' => '',
    'short_descr' => '',
    'start_dttm' => ''
  ]),
  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}}/annotation_layer/:pk/annotation/:annotation_id', [
  'body' => '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'end_dttm' => '',
  'json_metadata' => '',
  'long_descr' => '',
  'short_descr' => '',
  'start_dttm' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'end_dttm' => '',
  'json_metadata' => '',
  'long_descr' => '',
  'short_descr' => '',
  'start_dttm' => ''
]));
$request->setRequestUrl('{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id');
$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}}/annotation_layer/:pk/annotation/:annotation_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}'
import http.client

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

payload = "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/annotation_layer/:pk/annotation/:annotation_id", payload, headers)

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

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

url = "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"

payload = {
    "end_dttm": "",
    "json_metadata": "",
    "long_descr": "",
    "short_descr": "",
    "start_dttm": ""
}
headers = {"content-type": "application/json"}

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

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

url <- "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id"

payload <- "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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}}/annotation_layer/:pk/annotation/:annotation_id")

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  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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/annotation_layer/:pk/annotation/:annotation_id') do |req|
  req.body = "{\n  \"end_dttm\": \"\",\n  \"json_metadata\": \"\",\n  \"long_descr\": \"\",\n  \"short_descr\": \"\",\n  \"start_dttm\": \"\"\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}}/annotation_layer/:pk/annotation/:annotation_id";

    let payload = json!({
        "end_dttm": "",
        "json_metadata": "",
        "long_descr": "",
        "short_descr": "",
        "start_dttm": ""
    });

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

curl --request PUT \
  --url {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id \
  --header 'content-type: application/json' \
  --data '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}'
echo '{
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
}' |  \
  http PUT {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "end_dttm": "",\n  "json_metadata": "",\n  "long_descr": "",\n  "short_descr": "",\n  "start_dttm": ""\n}' \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "end_dttm": "",
  "json_metadata": "",
  "long_descr": "",
  "short_descr": "",
  "start_dttm": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk/annotation/:annotation_id")! 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()
PUT Update an Annotation layer
{{baseUrl}}/annotation_layer/:pk
QUERY PARAMS
pk
BODY json
{
  "descr": "",
  "name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/:pk");

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

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

(client/put "{{baseUrl}}/annotation_layer/:pk" {:content-type :json
                                                                :form-params {:descr ""
                                                                              :name ""}})
require "http/client"

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

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

func main() {

	url := "{{baseUrl}}/annotation_layer/:pk"

	payload := strings.NewReader("{\n  \"descr\": \"\",\n  \"name\": \"\"\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/annotation_layer/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/annotation_layer/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"descr\": \"\",\n  \"name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  descr: '',
  name: ''
});

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/annotation_layer/:pk',
  headers: {'content-type': 'application/json'},
  data: {descr: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"descr":"","name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/annotation_layer/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "descr": "",\n  "name": ""\n}'
};

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/annotation_layer/:pk',
  headers: {'content-type': 'application/json'},
  body: {descr: '', name: ''},
  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}}/annotation_layer/:pk');

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

req.type('json');
req.send({
  descr: '',
  name: ''
});

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}}/annotation_layer/:pk',
  headers: {'content-type': 'application/json'},
  data: {descr: '', name: ''}
};

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

const url = '{{baseUrl}}/annotation_layer/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"descr":"","name":""}'
};

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

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

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

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/:pk",
  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([
    'descr' => '',
    'name' => ''
  ]),
  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}}/annotation_layer/:pk', [
  'body' => '{
  "descr": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/:pk');
$request->setMethod(HTTP_METH_PUT);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'descr' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/annotation_layer/:pk');
$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}}/annotation_layer/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "descr": "",
  "name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "descr": "",
  "name": ""
}'
import http.client

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

payload = "{\n  \"descr\": \"\",\n  \"name\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/annotation_layer/:pk", payload, headers)

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

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

url = "{{baseUrl}}/annotation_layer/:pk"

payload = {
    "descr": "",
    "name": ""
}
headers = {"content-type": "application/json"}

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

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

url <- "{{baseUrl}}/annotation_layer/:pk"

payload <- "{\n  \"descr\": \"\",\n  \"name\": \"\"\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}}/annotation_layer/:pk")

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  \"descr\": \"\",\n  \"name\": \"\"\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/annotation_layer/:pk') do |req|
  req.body = "{\n  \"descr\": \"\",\n  \"name\": \"\"\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}}/annotation_layer/:pk";

    let payload = json!({
        "descr": "",
        "name": ""
    });

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

curl --request PUT \
  --url {{baseUrl}}/annotation_layer/:pk \
  --header 'content-type: application/json' \
  --data '{
  "descr": "",
  "name": ""
}'
echo '{
  "descr": "",
  "name": ""
}' |  \
  http PUT {{baseUrl}}/annotation_layer/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "descr": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/annotation_layer/:pk
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/:pk")! 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()
GET get -annotation_layer-related--column_name
{{baseUrl}}/annotation_layer/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/annotation_layer/related/:column_name");

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

(client/get "{{baseUrl}}/annotation_layer/related/:column_name")
require "http/client"

url = "{{baseUrl}}/annotation_layer/related/:column_name"

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}}/annotation_layer/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/annotation_layer/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/annotation_layer/related/:column_name"

	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/annotation_layer/related/:column_name HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/annotation_layer/related/:column_name"))
    .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}}/annotation_layer/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/annotation_layer/related/:column_name")
  .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}}/annotation_layer/related/:column_name');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/annotation_layer/related/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/annotation_layer/related/:column_name';
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}}/annotation_layer/related/:column_name',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/annotation_layer/related/:column_name")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/annotation_layer/related/:column_name',
  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}}/annotation_layer/related/:column_name'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/annotation_layer/related/:column_name');

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}}/annotation_layer/related/:column_name'
};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/annotation_layer/related/:column_name",
  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}}/annotation_layer/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/annotation_layer/related/:column_name');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/annotation_layer/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/annotation_layer/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/annotation_layer/related/:column_name' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/annotation_layer/related/:column_name")

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

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

url = "{{baseUrl}}/annotation_layer/related/:column_name"

response = requests.get(url)

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

url <- "{{baseUrl}}/annotation_layer/related/:column_name"

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

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

url = URI("{{baseUrl}}/annotation_layer/related/:column_name")

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/annotation_layer/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/annotation_layer/related/:column_name
http GET {{baseUrl}}/annotation_layer/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/annotation_layer/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/annotation_layer/related/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Reads off of the Redis events stream, using the user's JWT token and optional query params for last event received.
{{baseUrl}}/async_event/
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/async_event/")
require "http/client"

url = "{{baseUrl}}/async_event/"

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

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

func main() {

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

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/async_event/")
  .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}}/async_event/');

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

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

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

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/async_event/',
  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}}/async_event/'};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

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

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

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

echo $response->getBody();
setUrl('{{baseUrl}}/async_event/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/async_event/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/async_event/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/async_event/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/async_event/")

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

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

url = "{{baseUrl}}/async_event/"

response = requests.get(url)

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

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

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

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

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

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

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/async_event/
http GET {{baseUrl}}/async_event/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/async_event/
import Foundation

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

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

dataTask.resume()
POST Takes a list of datasources, finds the associated cache records and invalidates them and removes the database records
{{baseUrl}}/cachekey/invalidate
BODY json
{
  "datasource_uids": [],
  "datasources": [
    {
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    }
  ]
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}");

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

(client/post "{{baseUrl}}/cachekey/invalidate" {:content-type :json
                                                                :form-params {:datasource_uids []
                                                                              :datasources [{:database_name ""
                                                                                             :datasource_name ""
                                                                                             :datasource_type ""
                                                                                             :schema ""}]}})
require "http/client"

url = "{{baseUrl}}/cachekey/invalidate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\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}}/cachekey/invalidate"),
    Content = new StringContent("{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\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}}/cachekey/invalidate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/cachekey/invalidate"

	payload := strings.NewReader("{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\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/cachekey/invalidate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 167

{
  "datasource_uids": [],
  "datasources": [
    {
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    }
  ]
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/cachekey/invalidate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cachekey/invalidate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\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  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/cachekey/invalidate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/cachekey/invalidate")
  .header("content-type", "application/json")
  .body("{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}")
  .asString();
const data = JSON.stringify({
  datasource_uids: [],
  datasources: [
    {
      database_name: '',
      datasource_name: '',
      datasource_type: '',
      schema: ''
    }
  ]
});

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/cachekey/invalidate',
  headers: {'content-type': 'application/json'},
  data: {
    datasource_uids: [],
    datasources: [{database_name: '', datasource_name: '', datasource_type: '', schema: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/cachekey/invalidate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"datasource_uids":[],"datasources":[{"database_name":"","datasource_name":"","datasource_type":"","schema":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/cachekey/invalidate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "datasource_uids": [],\n  "datasources": [\n    {\n      "database_name": "",\n      "datasource_name": "",\n      "datasource_type": "",\n      "schema": ""\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  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/cachekey/invalidate")
  .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/cachekey/invalidate',
  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({
  datasource_uids: [],
  datasources: [{database_name: '', datasource_name: '', datasource_type: '', schema: ''}]
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/cachekey/invalidate',
  headers: {'content-type': 'application/json'},
  body: {
    datasource_uids: [],
    datasources: [{database_name: '', datasource_name: '', datasource_type: '', schema: ''}]
  },
  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}}/cachekey/invalidate');

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

req.type('json');
req.send({
  datasource_uids: [],
  datasources: [
    {
      database_name: '',
      datasource_name: '',
      datasource_type: '',
      schema: ''
    }
  ]
});

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}}/cachekey/invalidate',
  headers: {'content-type': 'application/json'},
  data: {
    datasource_uids: [],
    datasources: [{database_name: '', datasource_name: '', datasource_type: '', schema: ''}]
  }
};

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

const url = '{{baseUrl}}/cachekey/invalidate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"datasource_uids":[],"datasources":[{"database_name":"","datasource_name":"","datasource_type":"","schema":""}]}'
};

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 = @{ @"datasource_uids": @[  ],
                              @"datasources": @[ @{ @"database_name": @"", @"datasource_name": @"", @"datasource_type": @"", @"schema": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/cachekey/invalidate"]
                                                       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}}/cachekey/invalidate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/cachekey/invalidate",
  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([
    'datasource_uids' => [
        
    ],
    'datasources' => [
        [
                'database_name' => '',
                'datasource_name' => '',
                'datasource_type' => '',
                'schema' => ''
        ]
    ]
  ]),
  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}}/cachekey/invalidate', [
  'body' => '{
  "datasource_uids": [],
  "datasources": [
    {
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/cachekey/invalidate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'datasource_uids' => [
    
  ],
  'datasources' => [
    [
        'database_name' => '',
        'datasource_name' => '',
        'datasource_type' => '',
        'schema' => ''
    ]
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'datasource_uids' => [
    
  ],
  'datasources' => [
    [
        'database_name' => '',
        'datasource_name' => '',
        'datasource_type' => '',
        'schema' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/cachekey/invalidate');
$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}}/cachekey/invalidate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "datasource_uids": [],
  "datasources": [
    {
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    }
  ]
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/cachekey/invalidate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "datasource_uids": [],
  "datasources": [
    {
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    }
  ]
}'
import http.client

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

payload = "{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\n    }\n  ]\n}"

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

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

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

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

url = "{{baseUrl}}/cachekey/invalidate"

payload = {
    "datasource_uids": [],
    "datasources": [
        {
            "database_name": "",
            "datasource_name": "",
            "datasource_type": "",
            "schema": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

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

url <- "{{baseUrl}}/cachekey/invalidate"

payload <- "{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\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}}/cachekey/invalidate")

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  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\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/cachekey/invalidate') do |req|
  req.body = "{\n  \"datasource_uids\": [],\n  \"datasources\": [\n    {\n      \"database_name\": \"\",\n      \"datasource_name\": \"\",\n      \"datasource_type\": \"\",\n      \"schema\": \"\"\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}}/cachekey/invalidate";

    let payload = json!({
        "datasource_uids": (),
        "datasources": (
            json!({
                "database_name": "",
                "datasource_name": "",
                "datasource_type": "",
                "schema": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/cachekey/invalidate \
  --header 'content-type: application/json' \
  --data '{
  "datasource_uids": [],
  "datasources": [
    {
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    }
  ]
}'
echo '{
  "datasource_uids": [],
  "datasources": [
    {
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/cachekey/invalidate \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "datasource_uids": [],\n  "datasources": [\n    {\n      "database_name": "",\n      "datasource_name": "",\n      "datasource_type": "",\n      "schema": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/cachekey/invalidate
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "datasource_uids": [],
  "datasources": [
    [
      "database_name": "",
      "datasource_name": "",
      "datasource_type": "",
      "schema": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cachekey/invalidate")! 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()
PUT Changes a Chart.
{{baseUrl}}/chart/:pk
QUERY PARAMS
pk
BODY json
{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/:pk");

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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}");

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

(client/put "{{baseUrl}}/chart/:pk" {:content-type :json
                                                     :form-params {:cache_timeout 0
                                                                   :dashboards []
                                                                   :datasource_id 0
                                                                   :datasource_type ""
                                                                   :description ""
                                                                   :owners []
                                                                   :params ""
                                                                   :query_context ""
                                                                   :slice_name ""
                                                                   :viz_type ""}})
require "http/client"

url = "{{baseUrl}}/chart/:pk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\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}}/chart/:pk"),
    Content = new StringContent("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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}}/chart/:pk");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/:pk"

	payload := strings.NewReader("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\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/chart/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 205

{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/chart/:pk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/:pk"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/chart/:pk")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/chart/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  cache_timeout: 0,
  dashboards: [],
  datasource_id: 0,
  datasource_type: '',
  description: '',
  owners: [],
  params: '',
  query_context: '',
  slice_name: '',
  viz_type: ''
});

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/chart/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    cache_timeout: 0,
    dashboards: [],
    datasource_id: 0,
    datasource_type: '',
    description: '',
    owners: [],
    params: '',
    query_context: '',
    slice_name: '',
    viz_type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cache_timeout":0,"dashboards":[],"datasource_id":0,"datasource_type":"","description":"","owners":[],"params":"","query_context":"","slice_name":"","viz_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}}/chart/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cache_timeout": 0,\n  "dashboards": [],\n  "datasource_id": 0,\n  "datasource_type": "",\n  "description": "",\n  "owners": [],\n  "params": "",\n  "query_context": "",\n  "slice_name": "",\n  "viz_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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/chart/:pk")
  .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/chart/:pk',
  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({
  cache_timeout: 0,
  dashboards: [],
  datasource_id: 0,
  datasource_type: '',
  description: '',
  owners: [],
  params: '',
  query_context: '',
  slice_name: '',
  viz_type: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/chart/:pk',
  headers: {'content-type': 'application/json'},
  body: {
    cache_timeout: 0,
    dashboards: [],
    datasource_id: 0,
    datasource_type: '',
    description: '',
    owners: [],
    params: '',
    query_context: '',
    slice_name: '',
    viz_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('PUT', '{{baseUrl}}/chart/:pk');

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

req.type('json');
req.send({
  cache_timeout: 0,
  dashboards: [],
  datasource_id: 0,
  datasource_type: '',
  description: '',
  owners: [],
  params: '',
  query_context: '',
  slice_name: '',
  viz_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: 'PUT',
  url: '{{baseUrl}}/chart/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    cache_timeout: 0,
    dashboards: [],
    datasource_id: 0,
    datasource_type: '',
    description: '',
    owners: [],
    params: '',
    query_context: '',
    slice_name: '',
    viz_type: ''
  }
};

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

const url = '{{baseUrl}}/chart/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cache_timeout":0,"dashboards":[],"datasource_id":0,"datasource_type":"","description":"","owners":[],"params":"","query_context":"","slice_name":"","viz_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 = @{ @"cache_timeout": @0,
                              @"dashboards": @[  ],
                              @"datasource_id": @0,
                              @"datasource_type": @"",
                              @"description": @"",
                              @"owners": @[  ],
                              @"params": @"",
                              @"query_context": @"",
                              @"slice_name": @"",
                              @"viz_type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/chart/:pk"]
                                                       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}}/chart/:pk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/:pk",
  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([
    'cache_timeout' => 0,
    'dashboards' => [
        
    ],
    'datasource_id' => 0,
    'datasource_type' => '',
    'description' => '',
    'owners' => [
        
    ],
    'params' => '',
    'query_context' => '',
    'slice_name' => '',
    'viz_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('PUT', '{{baseUrl}}/chart/:pk', [
  'body' => '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/chart/:pk');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cache_timeout' => 0,
  'dashboards' => [
    
  ],
  'datasource_id' => 0,
  'datasource_type' => '',
  'description' => '',
  'owners' => [
    
  ],
  'params' => '',
  'query_context' => '',
  'slice_name' => '',
  'viz_type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'cache_timeout' => 0,
  'dashboards' => [
    
  ],
  'datasource_id' => 0,
  'datasource_type' => '',
  'description' => '',
  'owners' => [
    
  ],
  'params' => '',
  'query_context' => '',
  'slice_name' => '',
  'viz_type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/chart/:pk');
$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}}/chart/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}'
import http.client

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

payload = "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/chart/:pk", payload, headers)

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

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

url = "{{baseUrl}}/chart/:pk"

payload = {
    "cache_timeout": 0,
    "dashboards": [],
    "datasource_id": 0,
    "datasource_type": "",
    "description": "",
    "owners": [],
    "params": "",
    "query_context": "",
    "slice_name": "",
    "viz_type": ""
}
headers = {"content-type": "application/json"}

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

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

url <- "{{baseUrl}}/chart/:pk"

payload <- "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\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}}/chart/:pk")

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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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.put('/baseUrl/chart/:pk') do |req|
  req.body = "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\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}}/chart/:pk";

    let payload = json!({
        "cache_timeout": 0,
        "dashboards": (),
        "datasource_id": 0,
        "datasource_type": "",
        "description": "",
        "owners": (),
        "params": "",
        "query_context": "",
        "slice_name": "",
        "viz_type": ""
    });

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

curl --request PUT \
  --url {{baseUrl}}/chart/:pk \
  --header 'content-type: application/json' \
  --data '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}'
echo '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}' |  \
  http PUT {{baseUrl}}/chart/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "cache_timeout": 0,\n  "dashboards": [],\n  "datasource_id": 0,\n  "datasource_type": "",\n  "description": "",\n  "owners": [],\n  "params": "",\n  "query_context": "",\n  "slice_name": "",\n  "viz_type": ""\n}' \
  --output-document \
  - {{baseUrl}}/chart/:pk
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "result": {
    "viz_type": [
      "bar",
      "line_multi",
      "area",
      "table"
    ]
  }
}
GET Check favorited dashboards for current user
{{baseUrl}}/chart/favorite_status/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/favorite_status/");

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

(client/get "{{baseUrl}}/chart/favorite_status/")
require "http/client"

url = "{{baseUrl}}/chart/favorite_status/"

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

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

func main() {

	url := "{{baseUrl}}/chart/favorite_status/"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/favorite_status/")
  .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}}/chart/favorite_status/');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/favorite_status/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/favorite_status/';
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}}/chart/favorite_status/',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/favorite_status/',
  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}}/chart/favorite_status/'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/favorite_status/');

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}}/chart/favorite_status/'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/favorite_status/",
  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}}/chart/favorite_status/');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/favorite_status/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/favorite_status/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/favorite_status/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/favorite_status/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/favorite_status/")

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

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

url = "{{baseUrl}}/chart/favorite_status/"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/favorite_status/"

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

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

url = URI("{{baseUrl}}/chart/favorite_status/")

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/chart/favorite_status/') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/favorite_status/
http GET {{baseUrl}}/chart/favorite_status/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/favorite_status/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/favorite_status/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Compute and cache a screenshot.
{{baseUrl}}/chart/:pk/cache_screenshot/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/:pk/cache_screenshot/");

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

(client/get "{{baseUrl}}/chart/:pk/cache_screenshot/")
require "http/client"

url = "{{baseUrl}}/chart/:pk/cache_screenshot/"

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}}/chart/:pk/cache_screenshot/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/:pk/cache_screenshot/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/:pk/cache_screenshot/"

	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/chart/:pk/cache_screenshot/ HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/:pk/cache_screenshot/"))
    .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}}/chart/:pk/cache_screenshot/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/:pk/cache_screenshot/")
  .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}}/chart/:pk/cache_screenshot/');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/:pk/cache_screenshot/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/:pk/cache_screenshot/';
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}}/chart/:pk/cache_screenshot/',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/chart/:pk/cache_screenshot/")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/:pk/cache_screenshot/',
  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}}/chart/:pk/cache_screenshot/'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/:pk/cache_screenshot/');

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}}/chart/:pk/cache_screenshot/'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/:pk/cache_screenshot/",
  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}}/chart/:pk/cache_screenshot/');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/:pk/cache_screenshot/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/:pk/cache_screenshot/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/:pk/cache_screenshot/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/:pk/cache_screenshot/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/:pk/cache_screenshot/")

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

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

url = "{{baseUrl}}/chart/:pk/cache_screenshot/"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/:pk/cache_screenshot/"

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

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

url = URI("{{baseUrl}}/chart/:pk/cache_screenshot/")

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/chart/:pk/cache_screenshot/') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/:pk/cache_screenshot/
http GET {{baseUrl}}/chart/:pk/cache_screenshot/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/:pk/cache_screenshot/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/:pk/cache_screenshot/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Compute or get already computed chart thumbnail from cache.
{{baseUrl}}/chart/:pk/thumbnail/:digest/
QUERY PARAMS
pk
digest
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/:pk/thumbnail/:digest/");

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

(client/get "{{baseUrl}}/chart/:pk/thumbnail/:digest/")
require "http/client"

url = "{{baseUrl}}/chart/:pk/thumbnail/:digest/"

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}}/chart/:pk/thumbnail/:digest/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/:pk/thumbnail/:digest/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/:pk/thumbnail/:digest/"

	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/chart/:pk/thumbnail/:digest/ HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/:pk/thumbnail/:digest/"))
    .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}}/chart/:pk/thumbnail/:digest/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/:pk/thumbnail/:digest/")
  .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}}/chart/:pk/thumbnail/:digest/');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/:pk/thumbnail/:digest/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/:pk/thumbnail/:digest/';
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}}/chart/:pk/thumbnail/:digest/',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/chart/:pk/thumbnail/:digest/")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/:pk/thumbnail/:digest/',
  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}}/chart/:pk/thumbnail/:digest/'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/:pk/thumbnail/:digest/');

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}}/chart/:pk/thumbnail/:digest/'};

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

const url = '{{baseUrl}}/chart/:pk/thumbnail/:digest/';
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}}/chart/:pk/thumbnail/:digest/"]
                                                       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}}/chart/:pk/thumbnail/:digest/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/:pk/thumbnail/:digest/",
  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}}/chart/:pk/thumbnail/:digest/');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/:pk/thumbnail/:digest/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/:pk/thumbnail/:digest/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/:pk/thumbnail/:digest/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/:pk/thumbnail/:digest/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/:pk/thumbnail/:digest/")

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

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

url = "{{baseUrl}}/chart/:pk/thumbnail/:digest/"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/:pk/thumbnail/:digest/"

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

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

url = URI("{{baseUrl}}/chart/:pk/thumbnail/:digest/")

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/chart/:pk/thumbnail/:digest/') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/:pk/thumbnail/:digest/
http GET {{baseUrl}}/chart/:pk/thumbnail/:digest/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/:pk/thumbnail/:digest/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/:pk/thumbnail/:digest/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
POST Create a new Chart.
{{baseUrl}}/chart/
BODY json
{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}");

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

(client/post "{{baseUrl}}/chart/" {:content-type :json
                                                   :form-params {:cache_timeout 0
                                                                 :dashboards []
                                                                 :datasource_id 0
                                                                 :datasource_name ""
                                                                 :datasource_type ""
                                                                 :description ""
                                                                 :owners []
                                                                 :params ""
                                                                 :query_context ""
                                                                 :slice_name ""
                                                                 :viz_type ""}})
require "http/client"

url = "{{baseUrl}}/chart/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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}}/chart/"),
    Content = new StringContent("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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}}/chart/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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/chart/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 230

{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/chart/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/chart/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/chart/")
  .header("content-type", "application/json")
  .body("{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  cache_timeout: 0,
  dashboards: [],
  datasource_id: 0,
  datasource_name: '',
  datasource_type: '',
  description: '',
  owners: [],
  params: '',
  query_context: '',
  slice_name: '',
  viz_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}}/chart/');
xhr.setRequestHeader('content-type', 'application/json');

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/chart/',
  headers: {'content-type': 'application/json'},
  data: {
    cache_timeout: 0,
    dashboards: [],
    datasource_id: 0,
    datasource_name: '',
    datasource_type: '',
    description: '',
    owners: [],
    params: '',
    query_context: '',
    slice_name: '',
    viz_type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cache_timeout":0,"dashboards":[],"datasource_id":0,"datasource_name":"","datasource_type":"","description":"","owners":[],"params":"","query_context":"","slice_name":"","viz_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}}/chart/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cache_timeout": 0,\n  "dashboards": [],\n  "datasource_id": 0,\n  "datasource_name": "",\n  "datasource_type": "",\n  "description": "",\n  "owners": [],\n  "params": "",\n  "query_context": "",\n  "slice_name": "",\n  "viz_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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/chart/")
  .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/chart/',
  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({
  cache_timeout: 0,
  dashboards: [],
  datasource_id: 0,
  datasource_name: '',
  datasource_type: '',
  description: '',
  owners: [],
  params: '',
  query_context: '',
  slice_name: '',
  viz_type: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/chart/',
  headers: {'content-type': 'application/json'},
  body: {
    cache_timeout: 0,
    dashboards: [],
    datasource_id: 0,
    datasource_name: '',
    datasource_type: '',
    description: '',
    owners: [],
    params: '',
    query_context: '',
    slice_name: '',
    viz_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}}/chart/');

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

req.type('json');
req.send({
  cache_timeout: 0,
  dashboards: [],
  datasource_id: 0,
  datasource_name: '',
  datasource_type: '',
  description: '',
  owners: [],
  params: '',
  query_context: '',
  slice_name: '',
  viz_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}}/chart/',
  headers: {'content-type': 'application/json'},
  data: {
    cache_timeout: 0,
    dashboards: [],
    datasource_id: 0,
    datasource_name: '',
    datasource_type: '',
    description: '',
    owners: [],
    params: '',
    query_context: '',
    slice_name: '',
    viz_type: ''
  }
};

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

const url = '{{baseUrl}}/chart/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cache_timeout":0,"dashboards":[],"datasource_id":0,"datasource_name":"","datasource_type":"","description":"","owners":[],"params":"","query_context":"","slice_name":"","viz_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 = @{ @"cache_timeout": @0,
                              @"dashboards": @[  ],
                              @"datasource_id": @0,
                              @"datasource_name": @"",
                              @"datasource_type": @"",
                              @"description": @"",
                              @"owners": @[  ],
                              @"params": @"",
                              @"query_context": @"",
                              @"slice_name": @"",
                              @"viz_type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/chart/"]
                                                       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}}/chart/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/",
  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([
    'cache_timeout' => 0,
    'dashboards' => [
        
    ],
    'datasource_id' => 0,
    'datasource_name' => '',
    'datasource_type' => '',
    'description' => '',
    'owners' => [
        
    ],
    'params' => '',
    'query_context' => '',
    'slice_name' => '',
    'viz_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}}/chart/', [
  'body' => '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/chart/');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cache_timeout' => 0,
  'dashboards' => [
    
  ],
  'datasource_id' => 0,
  'datasource_name' => '',
  'datasource_type' => '',
  'description' => '',
  'owners' => [
    
  ],
  'params' => '',
  'query_context' => '',
  'slice_name' => '',
  'viz_type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'cache_timeout' => 0,
  'dashboards' => [
    
  ],
  'datasource_id' => 0,
  'datasource_name' => '',
  'datasource_type' => '',
  'description' => '',
  'owners' => [
    
  ],
  'params' => '',
  'query_context' => '',
  'slice_name' => '',
  'viz_type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/chart/');
$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}}/chart/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}'
import http.client

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

payload = "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/chart/"

payload = {
    "cache_timeout": 0,
    "dashboards": [],
    "datasource_id": 0,
    "datasource_name": "",
    "datasource_type": "",
    "description": "",
    "owners": [],
    "params": "",
    "query_context": "",
    "slice_name": "",
    "viz_type": ""
}
headers = {"content-type": "application/json"}

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

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

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

payload <- "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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}}/chart/")

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  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_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/chart/') do |req|
  req.body = "{\n  \"cache_timeout\": 0,\n  \"dashboards\": [],\n  \"datasource_id\": 0,\n  \"datasource_name\": \"\",\n  \"datasource_type\": \"\",\n  \"description\": \"\",\n  \"owners\": [],\n  \"params\": \"\",\n  \"query_context\": \"\",\n  \"slice_name\": \"\",\n  \"viz_type\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "cache_timeout": 0,
        "dashboards": (),
        "datasource_id": 0,
        "datasource_name": "",
        "datasource_type": "",
        "description": "",
        "owners": (),
        "params": "",
        "query_context": "",
        "slice_name": "",
        "viz_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);
}

curl --request POST \
  --url {{baseUrl}}/chart/ \
  --header 'content-type: application/json' \
  --data '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}'
echo '{
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
}' |  \
  http POST {{baseUrl}}/chart/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "cache_timeout": 0,\n  "dashboards": [],\n  "datasource_id": 0,\n  "datasource_name": "",\n  "datasource_type": "",\n  "description": "",\n  "owners": [],\n  "params": "",\n  "query_context": "",\n  "slice_name": "",\n  "viz_type": ""\n}' \
  --output-document \
  - {{baseUrl}}/chart/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cache_timeout": 0,
  "dashboards": [],
  "datasource_id": 0,
  "datasource_name": "",
  "datasource_type": "",
  "description": "",
  "owners": [],
  "params": "",
  "query_context": "",
  "slice_name": "",
  "viz_type": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "result": {
    "viz_type": [
      "bar",
      "line_multi",
      "area",
      "table"
    ]
  }
}
DELETE Deletes a Chart.
{{baseUrl}}/chart/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/:pk");

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

(client/delete "{{baseUrl}}/chart/:pk")
require "http/client"

url = "{{baseUrl}}/chart/:pk"

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}}/chart/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/:pk"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/chart/:pk")
  .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}}/chart/:pk');

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

const options = {method: 'DELETE', url: '{{baseUrl}}/chart/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/:pk';
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}}/chart/:pk',
  method: 'DELETE',
  headers: {}
};

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

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

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

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/:pk',
  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}}/chart/:pk'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/chart/:pk');

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}}/chart/:pk'};

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

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

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/:pk",
  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}}/chart/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/:pk');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/:pk' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/chart/:pk")

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

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

url = "{{baseUrl}}/chart/:pk"

response = requests.delete(url)

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

url <- "{{baseUrl}}/chart/:pk"

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

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

url = URI("{{baseUrl}}/chart/:pk")

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/chart/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

curl --request DELETE \
  --url {{baseUrl}}/chart/:pk
http DELETE {{baseUrl}}/chart/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/chart/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/:pk")! 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()
DELETE Deletes multiple Charts in a bulk operation.
{{baseUrl}}/chart/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/");

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

(client/delete "{{baseUrl}}/chart/")
require "http/client"

url = "{{baseUrl}}/chart/"

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}}/chart/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

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

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/chart/")
  .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}}/chart/');

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/';
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}}/chart/',
  method: 'DELETE',
  headers: {}
};

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

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

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

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/',
  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}}/chart/'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/chart/');

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

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

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

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/",
  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}}/chart/');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/chart/")

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

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

url = "{{baseUrl}}/chart/"

response = requests.delete(url)

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

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

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

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

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

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

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

curl --request DELETE \
  --url {{baseUrl}}/chart/
http DELETE {{baseUrl}}/chart/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/chart/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/")! 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()
GET Exports multiple charts and downloads them as YAML files
{{baseUrl}}/chart/export/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/export/");

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

(client/get "{{baseUrl}}/chart/export/")
require "http/client"

url = "{{baseUrl}}/chart/export/"

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

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

func main() {

	url := "{{baseUrl}}/chart/export/"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/export/")
  .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}}/chart/export/');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/export/';
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}}/chart/export/',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/export/',
  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}}/chart/export/'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/export/');

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}}/chart/export/'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/export/",
  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}}/chart/export/');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/export/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/export/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/export/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/export/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/export/")

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

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

url = "{{baseUrl}}/chart/export/"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/export/"

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

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

url = URI("{{baseUrl}}/chart/export/")

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/chart/export/') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/export/
http GET {{baseUrl}}/chart/export/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/export/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/export/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Get a chart detail information.
{{baseUrl}}/chart/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/:pk");

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

(client/get "{{baseUrl}}/chart/:pk")
require "http/client"

url = "{{baseUrl}}/chart/:pk"

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

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

func main() {

	url := "{{baseUrl}}/chart/:pk"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/:pk")
  .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}}/chart/:pk');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/:pk';
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}}/chart/:pk',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/:pk',
  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}}/chart/:pk'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/:pk');

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}}/chart/:pk'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/:pk",
  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}}/chart/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/:pk');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/:pk' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/:pk")

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

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

url = "{{baseUrl}}/chart/:pk"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/:pk"

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

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

url = URI("{{baseUrl}}/chart/:pk")

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/chart/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/:pk
http GET {{baseUrl}}/chart/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
GET Get a computed screenshot from cache.
{{baseUrl}}/chart/:pk/screenshot/:digest/
QUERY PARAMS
pk
digest
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/:pk/screenshot/:digest/");

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

(client/get "{{baseUrl}}/chart/:pk/screenshot/:digest/")
require "http/client"

url = "{{baseUrl}}/chart/:pk/screenshot/:digest/"

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}}/chart/:pk/screenshot/:digest/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/:pk/screenshot/:digest/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/:pk/screenshot/:digest/"

	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/chart/:pk/screenshot/:digest/ HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/:pk/screenshot/:digest/"))
    .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}}/chart/:pk/screenshot/:digest/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/:pk/screenshot/:digest/")
  .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}}/chart/:pk/screenshot/:digest/');

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/chart/:pk/screenshot/:digest/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/:pk/screenshot/:digest/';
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}}/chart/:pk/screenshot/:digest/',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/chart/:pk/screenshot/:digest/")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/:pk/screenshot/:digest/',
  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}}/chart/:pk/screenshot/:digest/'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/:pk/screenshot/:digest/');

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}}/chart/:pk/screenshot/:digest/'
};

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

const url = '{{baseUrl}}/chart/:pk/screenshot/:digest/';
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}}/chart/:pk/screenshot/:digest/"]
                                                       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}}/chart/:pk/screenshot/:digest/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/:pk/screenshot/:digest/",
  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}}/chart/:pk/screenshot/:digest/');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/:pk/screenshot/:digest/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/:pk/screenshot/:digest/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/:pk/screenshot/:digest/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/:pk/screenshot/:digest/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/:pk/screenshot/:digest/")

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

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

url = "{{baseUrl}}/chart/:pk/screenshot/:digest/"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/:pk/screenshot/:digest/"

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

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

url = URI("{{baseUrl}}/chart/:pk/screenshot/:digest/")

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/chart/:pk/screenshot/:digest/') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/:pk/screenshot/:digest/
http GET {{baseUrl}}/chart/:pk/screenshot/:digest/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/:pk/screenshot/:digest/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/:pk/screenshot/:digest/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Get a list of all possible owners for a chart. Use `owners` has the `column_name` parameter
{{baseUrl}}/chart/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/related/:column_name");

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

(client/get "{{baseUrl}}/chart/related/:column_name")
require "http/client"

url = "{{baseUrl}}/chart/related/:column_name"

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}}/chart/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/related/:column_name"

	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/chart/related/:column_name HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/related/:column_name"))
    .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}}/chart/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/related/:column_name")
  .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}}/chart/related/:column_name');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/related/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/related/:column_name';
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}}/chart/related/:column_name',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/chart/related/:column_name")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/related/:column_name',
  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}}/chart/related/:column_name'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/related/:column_name');

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}}/chart/related/:column_name'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/related/:column_name",
  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}}/chart/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/related/:column_name');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/related/:column_name' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/related/:column_name")

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

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

url = "{{baseUrl}}/chart/related/:column_name"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/related/:column_name"

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

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

url = URI("{{baseUrl}}/chart/related/:column_name")

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/chart/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/related/:column_name
http GET {{baseUrl}}/chart/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/related/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Get a list of charts, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/chart/
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

(client/get "{{baseUrl}}/chart/")
require "http/client"

url = "{{baseUrl}}/chart/"

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

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

func main() {

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

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/")
  .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}}/chart/');

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

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

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

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/',
  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}}/chart/'};

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

  console.log(body);
});
const unirest = require('unirest');

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

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

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

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

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

echo $response->getBody();
setUrl('{{baseUrl}}/chart/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/")

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

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

url = "{{baseUrl}}/chart/"

response = requests.get(url)

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

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

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

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

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

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

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/
http GET {{baseUrl}}/chart/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Several metadata information about chart API endpoints.
{{baseUrl}}/chart/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/_info");

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

(client/get "{{baseUrl}}/chart/_info")
require "http/client"

url = "{{baseUrl}}/chart/_info"

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

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

func main() {

	url := "{{baseUrl}}/chart/_info"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/_info")
  .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}}/chart/_info');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/_info';
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}}/chart/_info',
  method: 'GET',
  headers: {}
};

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

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

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/_info',
  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}}/chart/_info'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/_info');

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}}/chart/_info'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/_info",
  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}}/chart/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/_info');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/_info' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/_info")

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

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

url = "{{baseUrl}}/chart/_info"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/_info"

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

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

url = URI("{{baseUrl}}/chart/_info")

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/chart/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/_info
http GET {{baseUrl}}/chart/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/_info")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Takes a chart ID and uses the query context stored when the chart was saved to return payload data response.
{{baseUrl}}/chart/:pk/data/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/:pk/data/");

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

(client/get "{{baseUrl}}/chart/:pk/data/")
require "http/client"

url = "{{baseUrl}}/chart/:pk/data/"

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}}/chart/:pk/data/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/:pk/data/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/:pk/data/"

	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/chart/:pk/data/ HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/:pk/data/"))
    .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}}/chart/:pk/data/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/:pk/data/")
  .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}}/chart/:pk/data/');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/:pk/data/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/:pk/data/';
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}}/chart/:pk/data/',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/chart/:pk/data/")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/:pk/data/',
  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}}/chart/:pk/data/'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/:pk/data/');

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}}/chart/:pk/data/'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/:pk/data/",
  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}}/chart/:pk/data/');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/:pk/data/');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/:pk/data/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/:pk/data/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/:pk/data/' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/:pk/data/")

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

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

url = "{{baseUrl}}/chart/:pk/data/"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/:pk/data/"

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

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

url = URI("{{baseUrl}}/chart/:pk/data/")

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/chart/:pk/data/') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/:pk/data/
http GET {{baseUrl}}/chart/:pk/data/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/:pk/data/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/:pk/data/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Takes a query context cache key and returns payload data response for the given query.
{{baseUrl}}/chart/data/:cache_key
QUERY PARAMS
cache_key
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/chart/data/:cache_key");

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

(client/get "{{baseUrl}}/chart/data/:cache_key")
require "http/client"

url = "{{baseUrl}}/chart/data/:cache_key"

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}}/chart/data/:cache_key"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/data/:cache_key");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/data/:cache_key"

	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/chart/data/:cache_key HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/data/:cache_key"))
    .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}}/chart/data/:cache_key")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/chart/data/:cache_key")
  .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}}/chart/data/:cache_key');

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

const options = {method: 'GET', url: '{{baseUrl}}/chart/data/:cache_key'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/data/:cache_key';
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}}/chart/data/:cache_key',
  method: 'GET',
  headers: {}
};

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

val request = Request.Builder()
  .url("{{baseUrl}}/chart/data/:cache_key")
  .get()
  .build()

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

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/data/:cache_key',
  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}}/chart/data/:cache_key'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/chart/data/:cache_key');

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}}/chart/data/:cache_key'};

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/data/:cache_key",
  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}}/chart/data/:cache_key');

echo $response->getBody();
setUrl('{{baseUrl}}/chart/data/:cache_key');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/chart/data/:cache_key');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/data/:cache_key' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/data/:cache_key' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/chart/data/:cache_key")

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

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

url = "{{baseUrl}}/chart/data/:cache_key"

response = requests.get(url)

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

url <- "{{baseUrl}}/chart/data/:cache_key"

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

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

url = URI("{{baseUrl}}/chart/data/:cache_key")

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/chart/data/:cache_key') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/chart/data/:cache_key
http GET {{baseUrl}}/chart/data/:cache_key
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/chart/data/:cache_key
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/data/:cache_key")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
POST Takes a query context constructed in the client and returns payload data response for the given query.
{{baseUrl}}/chart/data
BODY json
{
  "datasource": {
    "id": 0,
    "type": ""
  },
  "force": false,
  "queries": [
    {
      "annotation_layers": [
        {
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": {},
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        }
      ],
      "applied_time_extras": {},
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        {
          "col": "",
          "op": "",
          "val": ""
        }
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [
        {}
      ],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": {},
      "where": ""
    }
  ],
  "result_format": "",
  "result_type": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}");

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

(client/post "{{baseUrl}}/chart/data" {:content-type :json
                                                       :form-params {:datasource {:id 0
                                                                                  :type ""}
                                                                     :force false
                                                                     :queries [{:annotation_layers [{:annotationType ""
                                                                                                     :color ""
                                                                                                     :descriptionColumns []
                                                                                                     :hideLine false
                                                                                                     :intervalEndColumn ""
                                                                                                     :name ""
                                                                                                     :opacity ""
                                                                                                     :overrides {}
                                                                                                     :show false
                                                                                                     :showMarkers false
                                                                                                     :sourceType ""
                                                                                                     :style ""
                                                                                                     :timeColumn ""
                                                                                                     :titleColumn ""
                                                                                                     :value ""
                                                                                                     :width ""}]
                                                                                :applied_time_extras {}
                                                                                :apply_fetch_values_predicate false
                                                                                :columns []
                                                                                :datasource ""
                                                                                :druid_time_origin ""
                                                                                :extras ""
                                                                                :filters [{:col ""
                                                                                           :op ""
                                                                                           :val ""}]
                                                                                :granularity ""
                                                                                :granularity_sqla ""
                                                                                :groupby []
                                                                                :having ""
                                                                                :having_filters [{}]
                                                                                :is_rowcount false
                                                                                :is_timeseries false
                                                                                :metrics []
                                                                                :order_desc false
                                                                                :orderby []
                                                                                :post_processing []
                                                                                :result_type ""
                                                                                :row_limit 0
                                                                                :row_offset 0
                                                                                :time_offsets []
                                                                                :time_range ""
                                                                                :time_shift ""
                                                                                :timeseries_limit 0
                                                                                :timeseries_limit_metric ""
                                                                                :url_params {}
                                                                                :where ""}]
                                                                     :result_format ""
                                                                     :result_type ""}})
require "http/client"

url = "{{baseUrl}}/chart/data"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_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}}/chart/data"),
    Content = new StringContent("{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_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}}/chart/data");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/data"

	payload := strings.NewReader("{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_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/chart/data HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1477

{
  "datasource": {
    "id": 0,
    "type": ""
  },
  "force": false,
  "queries": [
    {
      "annotation_layers": [
        {
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": {},
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        }
      ],
      "applied_time_extras": {},
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        {
          "col": "",
          "op": "",
          "val": ""
        }
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [
        {}
      ],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": {},
      "where": ""
    }
  ],
  "result_format": "",
  "result_type": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/chart/data")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/data"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_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  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/chart/data")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/chart/data")
  .header("content-type", "application/json")
  .body("{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  datasource: {
    id: 0,
    type: ''
  },
  force: false,
  queries: [
    {
      annotation_layers: [
        {
          annotationType: '',
          color: '',
          descriptionColumns: [],
          hideLine: false,
          intervalEndColumn: '',
          name: '',
          opacity: '',
          overrides: {},
          show: false,
          showMarkers: false,
          sourceType: '',
          style: '',
          timeColumn: '',
          titleColumn: '',
          value: '',
          width: ''
        }
      ],
      applied_time_extras: {},
      apply_fetch_values_predicate: false,
      columns: [],
      datasource: '',
      druid_time_origin: '',
      extras: '',
      filters: [
        {
          col: '',
          op: '',
          val: ''
        }
      ],
      granularity: '',
      granularity_sqla: '',
      groupby: [],
      having: '',
      having_filters: [
        {}
      ],
      is_rowcount: false,
      is_timeseries: false,
      metrics: [],
      order_desc: false,
      orderby: [],
      post_processing: [],
      result_type: '',
      row_limit: 0,
      row_offset: 0,
      time_offsets: [],
      time_range: '',
      time_shift: '',
      timeseries_limit: 0,
      timeseries_limit_metric: '',
      url_params: {},
      where: ''
    }
  ],
  result_format: '',
  result_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}}/chart/data');
xhr.setRequestHeader('content-type', 'application/json');

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/chart/data',
  headers: {'content-type': 'application/json'},
  data: {
    datasource: {id: 0, type: ''},
    force: false,
    queries: [
      {
        annotation_layers: [
          {
            annotationType: '',
            color: '',
            descriptionColumns: [],
            hideLine: false,
            intervalEndColumn: '',
            name: '',
            opacity: '',
            overrides: {},
            show: false,
            showMarkers: false,
            sourceType: '',
            style: '',
            timeColumn: '',
            titleColumn: '',
            value: '',
            width: ''
          }
        ],
        applied_time_extras: {},
        apply_fetch_values_predicate: false,
        columns: [],
        datasource: '',
        druid_time_origin: '',
        extras: '',
        filters: [{col: '', op: '', val: ''}],
        granularity: '',
        granularity_sqla: '',
        groupby: [],
        having: '',
        having_filters: [{}],
        is_rowcount: false,
        is_timeseries: false,
        metrics: [],
        order_desc: false,
        orderby: [],
        post_processing: [],
        result_type: '',
        row_limit: 0,
        row_offset: 0,
        time_offsets: [],
        time_range: '',
        time_shift: '',
        timeseries_limit: 0,
        timeseries_limit_metric: '',
        url_params: {},
        where: ''
      }
    ],
    result_format: '',
    result_type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"datasource":{"id":0,"type":""},"force":false,"queries":[{"annotation_layers":[{"annotationType":"","color":"","descriptionColumns":[],"hideLine":false,"intervalEndColumn":"","name":"","opacity":"","overrides":{},"show":false,"showMarkers":false,"sourceType":"","style":"","timeColumn":"","titleColumn":"","value":"","width":""}],"applied_time_extras":{},"apply_fetch_values_predicate":false,"columns":[],"datasource":"","druid_time_origin":"","extras":"","filters":[{"col":"","op":"","val":""}],"granularity":"","granularity_sqla":"","groupby":[],"having":"","having_filters":[{}],"is_rowcount":false,"is_timeseries":false,"metrics":[],"order_desc":false,"orderby":[],"post_processing":[],"result_type":"","row_limit":0,"row_offset":0,"time_offsets":[],"time_range":"","time_shift":"","timeseries_limit":0,"timeseries_limit_metric":"","url_params":{},"where":""}],"result_format":"","result_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}}/chart/data',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "datasource": {\n    "id": 0,\n    "type": ""\n  },\n  "force": false,\n  "queries": [\n    {\n      "annotation_layers": [\n        {\n          "annotationType": "",\n          "color": "",\n          "descriptionColumns": [],\n          "hideLine": false,\n          "intervalEndColumn": "",\n          "name": "",\n          "opacity": "",\n          "overrides": {},\n          "show": false,\n          "showMarkers": false,\n          "sourceType": "",\n          "style": "",\n          "timeColumn": "",\n          "titleColumn": "",\n          "value": "",\n          "width": ""\n        }\n      ],\n      "applied_time_extras": {},\n      "apply_fetch_values_predicate": false,\n      "columns": [],\n      "datasource": "",\n      "druid_time_origin": "",\n      "extras": "",\n      "filters": [\n        {\n          "col": "",\n          "op": "",\n          "val": ""\n        }\n      ],\n      "granularity": "",\n      "granularity_sqla": "",\n      "groupby": [],\n      "having": "",\n      "having_filters": [\n        {}\n      ],\n      "is_rowcount": false,\n      "is_timeseries": false,\n      "metrics": [],\n      "order_desc": false,\n      "orderby": [],\n      "post_processing": [],\n      "result_type": "",\n      "row_limit": 0,\n      "row_offset": 0,\n      "time_offsets": [],\n      "time_range": "",\n      "time_shift": "",\n      "timeseries_limit": 0,\n      "timeseries_limit_metric": "",\n      "url_params": {},\n      "where": ""\n    }\n  ],\n  "result_format": "",\n  "result_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  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/chart/data")
  .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/chart/data',
  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({
  datasource: {id: 0, type: ''},
  force: false,
  queries: [
    {
      annotation_layers: [
        {
          annotationType: '',
          color: '',
          descriptionColumns: [],
          hideLine: false,
          intervalEndColumn: '',
          name: '',
          opacity: '',
          overrides: {},
          show: false,
          showMarkers: false,
          sourceType: '',
          style: '',
          timeColumn: '',
          titleColumn: '',
          value: '',
          width: ''
        }
      ],
      applied_time_extras: {},
      apply_fetch_values_predicate: false,
      columns: [],
      datasource: '',
      druid_time_origin: '',
      extras: '',
      filters: [{col: '', op: '', val: ''}],
      granularity: '',
      granularity_sqla: '',
      groupby: [],
      having: '',
      having_filters: [{}],
      is_rowcount: false,
      is_timeseries: false,
      metrics: [],
      order_desc: false,
      orderby: [],
      post_processing: [],
      result_type: '',
      row_limit: 0,
      row_offset: 0,
      time_offsets: [],
      time_range: '',
      time_shift: '',
      timeseries_limit: 0,
      timeseries_limit_metric: '',
      url_params: {},
      where: ''
    }
  ],
  result_format: '',
  result_type: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/chart/data',
  headers: {'content-type': 'application/json'},
  body: {
    datasource: {id: 0, type: ''},
    force: false,
    queries: [
      {
        annotation_layers: [
          {
            annotationType: '',
            color: '',
            descriptionColumns: [],
            hideLine: false,
            intervalEndColumn: '',
            name: '',
            opacity: '',
            overrides: {},
            show: false,
            showMarkers: false,
            sourceType: '',
            style: '',
            timeColumn: '',
            titleColumn: '',
            value: '',
            width: ''
          }
        ],
        applied_time_extras: {},
        apply_fetch_values_predicate: false,
        columns: [],
        datasource: '',
        druid_time_origin: '',
        extras: '',
        filters: [{col: '', op: '', val: ''}],
        granularity: '',
        granularity_sqla: '',
        groupby: [],
        having: '',
        having_filters: [{}],
        is_rowcount: false,
        is_timeseries: false,
        metrics: [],
        order_desc: false,
        orderby: [],
        post_processing: [],
        result_type: '',
        row_limit: 0,
        row_offset: 0,
        time_offsets: [],
        time_range: '',
        time_shift: '',
        timeseries_limit: 0,
        timeseries_limit_metric: '',
        url_params: {},
        where: ''
      }
    ],
    result_format: '',
    result_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}}/chart/data');

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

req.type('json');
req.send({
  datasource: {
    id: 0,
    type: ''
  },
  force: false,
  queries: [
    {
      annotation_layers: [
        {
          annotationType: '',
          color: '',
          descriptionColumns: [],
          hideLine: false,
          intervalEndColumn: '',
          name: '',
          opacity: '',
          overrides: {},
          show: false,
          showMarkers: false,
          sourceType: '',
          style: '',
          timeColumn: '',
          titleColumn: '',
          value: '',
          width: ''
        }
      ],
      applied_time_extras: {},
      apply_fetch_values_predicate: false,
      columns: [],
      datasource: '',
      druid_time_origin: '',
      extras: '',
      filters: [
        {
          col: '',
          op: '',
          val: ''
        }
      ],
      granularity: '',
      granularity_sqla: '',
      groupby: [],
      having: '',
      having_filters: [
        {}
      ],
      is_rowcount: false,
      is_timeseries: false,
      metrics: [],
      order_desc: false,
      orderby: [],
      post_processing: [],
      result_type: '',
      row_limit: 0,
      row_offset: 0,
      time_offsets: [],
      time_range: '',
      time_shift: '',
      timeseries_limit: 0,
      timeseries_limit_metric: '',
      url_params: {},
      where: ''
    }
  ],
  result_format: '',
  result_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}}/chart/data',
  headers: {'content-type': 'application/json'},
  data: {
    datasource: {id: 0, type: ''},
    force: false,
    queries: [
      {
        annotation_layers: [
          {
            annotationType: '',
            color: '',
            descriptionColumns: [],
            hideLine: false,
            intervalEndColumn: '',
            name: '',
            opacity: '',
            overrides: {},
            show: false,
            showMarkers: false,
            sourceType: '',
            style: '',
            timeColumn: '',
            titleColumn: '',
            value: '',
            width: ''
          }
        ],
        applied_time_extras: {},
        apply_fetch_values_predicate: false,
        columns: [],
        datasource: '',
        druid_time_origin: '',
        extras: '',
        filters: [{col: '', op: '', val: ''}],
        granularity: '',
        granularity_sqla: '',
        groupby: [],
        having: '',
        having_filters: [{}],
        is_rowcount: false,
        is_timeseries: false,
        metrics: [],
        order_desc: false,
        orderby: [],
        post_processing: [],
        result_type: '',
        row_limit: 0,
        row_offset: 0,
        time_offsets: [],
        time_range: '',
        time_shift: '',
        timeseries_limit: 0,
        timeseries_limit_metric: '',
        url_params: {},
        where: ''
      }
    ],
    result_format: '',
    result_type: ''
  }
};

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

const url = '{{baseUrl}}/chart/data';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"datasource":{"id":0,"type":""},"force":false,"queries":[{"annotation_layers":[{"annotationType":"","color":"","descriptionColumns":[],"hideLine":false,"intervalEndColumn":"","name":"","opacity":"","overrides":{},"show":false,"showMarkers":false,"sourceType":"","style":"","timeColumn":"","titleColumn":"","value":"","width":""}],"applied_time_extras":{},"apply_fetch_values_predicate":false,"columns":[],"datasource":"","druid_time_origin":"","extras":"","filters":[{"col":"","op":"","val":""}],"granularity":"","granularity_sqla":"","groupby":[],"having":"","having_filters":[{}],"is_rowcount":false,"is_timeseries":false,"metrics":[],"order_desc":false,"orderby":[],"post_processing":[],"result_type":"","row_limit":0,"row_offset":0,"time_offsets":[],"time_range":"","time_shift":"","timeseries_limit":0,"timeseries_limit_metric":"","url_params":{},"where":""}],"result_format":"","result_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 = @{ @"datasource": @{ @"id": @0, @"type": @"" },
                              @"force": @NO,
                              @"queries": @[ @{ @"annotation_layers": @[ @{ @"annotationType": @"", @"color": @"", @"descriptionColumns": @[  ], @"hideLine": @NO, @"intervalEndColumn": @"", @"name": @"", @"opacity": @"", @"overrides": @{  }, @"show": @NO, @"showMarkers": @NO, @"sourceType": @"", @"style": @"", @"timeColumn": @"", @"titleColumn": @"", @"value": @"", @"width": @"" } ], @"applied_time_extras": @{  }, @"apply_fetch_values_predicate": @NO, @"columns": @[  ], @"datasource": @"", @"druid_time_origin": @"", @"extras": @"", @"filters": @[ @{ @"col": @"", @"op": @"", @"val": @"" } ], @"granularity": @"", @"granularity_sqla": @"", @"groupby": @[  ], @"having": @"", @"having_filters": @[ @{  } ], @"is_rowcount": @NO, @"is_timeseries": @NO, @"metrics": @[  ], @"order_desc": @NO, @"orderby": @[  ], @"post_processing": @[  ], @"result_type": @"", @"row_limit": @0, @"row_offset": @0, @"time_offsets": @[  ], @"time_range": @"", @"time_shift": @"", @"timeseries_limit": @0, @"timeseries_limit_metric": @"", @"url_params": @{  }, @"where": @"" } ],
                              @"result_format": @"",
                              @"result_type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/chart/data"]
                                                       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}}/chart/data" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/data",
  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([
    'datasource' => [
        'id' => 0,
        'type' => ''
    ],
    'force' => null,
    'queries' => [
        [
                'annotation_layers' => [
                                [
                                                                'annotationType' => '',
                                                                'color' => '',
                                                                'descriptionColumns' => [
                                                                                                                                
                                                                ],
                                                                'hideLine' => null,
                                                                'intervalEndColumn' => '',
                                                                'name' => '',
                                                                'opacity' => '',
                                                                'overrides' => [
                                                                                                                                
                                                                ],
                                                                'show' => null,
                                                                'showMarkers' => null,
                                                                'sourceType' => '',
                                                                'style' => '',
                                                                'timeColumn' => '',
                                                                'titleColumn' => '',
                                                                'value' => '',
                                                                'width' => ''
                                ]
                ],
                'applied_time_extras' => [
                                
                ],
                'apply_fetch_values_predicate' => null,
                'columns' => [
                                
                ],
                'datasource' => '',
                'druid_time_origin' => '',
                'extras' => '',
                'filters' => [
                                [
                                                                'col' => '',
                                                                'op' => '',
                                                                'val' => ''
                                ]
                ],
                'granularity' => '',
                'granularity_sqla' => '',
                'groupby' => [
                                
                ],
                'having' => '',
                'having_filters' => [
                                [
                                                                
                                ]
                ],
                'is_rowcount' => null,
                'is_timeseries' => null,
                'metrics' => [
                                
                ],
                'order_desc' => null,
                'orderby' => [
                                
                ],
                'post_processing' => [
                                
                ],
                'result_type' => '',
                'row_limit' => 0,
                'row_offset' => 0,
                'time_offsets' => [
                                
                ],
                'time_range' => '',
                'time_shift' => '',
                'timeseries_limit' => 0,
                'timeseries_limit_metric' => '',
                'url_params' => [
                                
                ],
                'where' => ''
        ]
    ],
    'result_format' => '',
    'result_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}}/chart/data', [
  'body' => '{
  "datasource": {
    "id": 0,
    "type": ""
  },
  "force": false,
  "queries": [
    {
      "annotation_layers": [
        {
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": {},
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        }
      ],
      "applied_time_extras": {},
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        {
          "col": "",
          "op": "",
          "val": ""
        }
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [
        {}
      ],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": {},
      "where": ""
    }
  ],
  "result_format": "",
  "result_type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/chart/data');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'datasource' => [
    'id' => 0,
    'type' => ''
  ],
  'force' => null,
  'queries' => [
    [
        'annotation_layers' => [
                [
                                'annotationType' => '',
                                'color' => '',
                                'descriptionColumns' => [
                                                                
                                ],
                                'hideLine' => null,
                                'intervalEndColumn' => '',
                                'name' => '',
                                'opacity' => '',
                                'overrides' => [
                                                                
                                ],
                                'show' => null,
                                'showMarkers' => null,
                                'sourceType' => '',
                                'style' => '',
                                'timeColumn' => '',
                                'titleColumn' => '',
                                'value' => '',
                                'width' => ''
                ]
        ],
        'applied_time_extras' => [
                
        ],
        'apply_fetch_values_predicate' => null,
        'columns' => [
                
        ],
        'datasource' => '',
        'druid_time_origin' => '',
        'extras' => '',
        'filters' => [
                [
                                'col' => '',
                                'op' => '',
                                'val' => ''
                ]
        ],
        'granularity' => '',
        'granularity_sqla' => '',
        'groupby' => [
                
        ],
        'having' => '',
        'having_filters' => [
                [
                                
                ]
        ],
        'is_rowcount' => null,
        'is_timeseries' => null,
        'metrics' => [
                
        ],
        'order_desc' => null,
        'orderby' => [
                
        ],
        'post_processing' => [
                
        ],
        'result_type' => '',
        'row_limit' => 0,
        'row_offset' => 0,
        'time_offsets' => [
                
        ],
        'time_range' => '',
        'time_shift' => '',
        'timeseries_limit' => 0,
        'timeseries_limit_metric' => '',
        'url_params' => [
                
        ],
        'where' => ''
    ]
  ],
  'result_format' => '',
  'result_type' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'datasource' => [
    'id' => 0,
    'type' => ''
  ],
  'force' => null,
  'queries' => [
    [
        'annotation_layers' => [
                [
                                'annotationType' => '',
                                'color' => '',
                                'descriptionColumns' => [
                                                                
                                ],
                                'hideLine' => null,
                                'intervalEndColumn' => '',
                                'name' => '',
                                'opacity' => '',
                                'overrides' => [
                                                                
                                ],
                                'show' => null,
                                'showMarkers' => null,
                                'sourceType' => '',
                                'style' => '',
                                'timeColumn' => '',
                                'titleColumn' => '',
                                'value' => '',
                                'width' => ''
                ]
        ],
        'applied_time_extras' => [
                
        ],
        'apply_fetch_values_predicate' => null,
        'columns' => [
                
        ],
        'datasource' => '',
        'druid_time_origin' => '',
        'extras' => '',
        'filters' => [
                [
                                'col' => '',
                                'op' => '',
                                'val' => ''
                ]
        ],
        'granularity' => '',
        'granularity_sqla' => '',
        'groupby' => [
                
        ],
        'having' => '',
        'having_filters' => [
                [
                                
                ]
        ],
        'is_rowcount' => null,
        'is_timeseries' => null,
        'metrics' => [
                
        ],
        'order_desc' => null,
        'orderby' => [
                
        ],
        'post_processing' => [
                
        ],
        'result_type' => '',
        'row_limit' => 0,
        'row_offset' => 0,
        'time_offsets' => [
                
        ],
        'time_range' => '',
        'time_shift' => '',
        'timeseries_limit' => 0,
        'timeseries_limit_metric' => '',
        'url_params' => [
                
        ],
        'where' => ''
    ]
  ],
  'result_format' => '',
  'result_type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/chart/data');
$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}}/chart/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "datasource": {
    "id": 0,
    "type": ""
  },
  "force": false,
  "queries": [
    {
      "annotation_layers": [
        {
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": {},
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        }
      ],
      "applied_time_extras": {},
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        {
          "col": "",
          "op": "",
          "val": ""
        }
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [
        {}
      ],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": {},
      "where": ""
    }
  ],
  "result_format": "",
  "result_type": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/data' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "datasource": {
    "id": 0,
    "type": ""
  },
  "force": false,
  "queries": [
    {
      "annotation_layers": [
        {
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": {},
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        }
      ],
      "applied_time_extras": {},
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        {
          "col": "",
          "op": "",
          "val": ""
        }
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [
        {}
      ],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": {},
      "where": ""
    }
  ],
  "result_format": "",
  "result_type": ""
}'
import http.client

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

payload = "{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/chart/data"

payload = {
    "datasource": {
        "id": 0,
        "type": ""
    },
    "force": False,
    "queries": [
        {
            "annotation_layers": [
                {
                    "annotationType": "",
                    "color": "",
                    "descriptionColumns": [],
                    "hideLine": False,
                    "intervalEndColumn": "",
                    "name": "",
                    "opacity": "",
                    "overrides": {},
                    "show": False,
                    "showMarkers": False,
                    "sourceType": "",
                    "style": "",
                    "timeColumn": "",
                    "titleColumn": "",
                    "value": "",
                    "width": ""
                }
            ],
            "applied_time_extras": {},
            "apply_fetch_values_predicate": False,
            "columns": [],
            "datasource": "",
            "druid_time_origin": "",
            "extras": "",
            "filters": [
                {
                    "col": "",
                    "op": "",
                    "val": ""
                }
            ],
            "granularity": "",
            "granularity_sqla": "",
            "groupby": [],
            "having": "",
            "having_filters": [{}],
            "is_rowcount": False,
            "is_timeseries": False,
            "metrics": [],
            "order_desc": False,
            "orderby": [],
            "post_processing": [],
            "result_type": "",
            "row_limit": 0,
            "row_offset": 0,
            "time_offsets": [],
            "time_range": "",
            "time_shift": "",
            "timeseries_limit": 0,
            "timeseries_limit_metric": "",
            "url_params": {},
            "where": ""
        }
    ],
    "result_format": "",
    "result_type": ""
}
headers = {"content-type": "application/json"}

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

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

url <- "{{baseUrl}}/chart/data"

payload <- "{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_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}}/chart/data")

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  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_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/chart/data') do |req|
  req.body = "{\n  \"datasource\": {\n    \"id\": 0,\n    \"type\": \"\"\n  },\n  \"force\": false,\n  \"queries\": [\n    {\n      \"annotation_layers\": [\n        {\n          \"annotationType\": \"\",\n          \"color\": \"\",\n          \"descriptionColumns\": [],\n          \"hideLine\": false,\n          \"intervalEndColumn\": \"\",\n          \"name\": \"\",\n          \"opacity\": \"\",\n          \"overrides\": {},\n          \"show\": false,\n          \"showMarkers\": false,\n          \"sourceType\": \"\",\n          \"style\": \"\",\n          \"timeColumn\": \"\",\n          \"titleColumn\": \"\",\n          \"value\": \"\",\n          \"width\": \"\"\n        }\n      ],\n      \"applied_time_extras\": {},\n      \"apply_fetch_values_predicate\": false,\n      \"columns\": [],\n      \"datasource\": \"\",\n      \"druid_time_origin\": \"\",\n      \"extras\": \"\",\n      \"filters\": [\n        {\n          \"col\": \"\",\n          \"op\": \"\",\n          \"val\": \"\"\n        }\n      ],\n      \"granularity\": \"\",\n      \"granularity_sqla\": \"\",\n      \"groupby\": [],\n      \"having\": \"\",\n      \"having_filters\": [\n        {}\n      ],\n      \"is_rowcount\": false,\n      \"is_timeseries\": false,\n      \"metrics\": [],\n      \"order_desc\": false,\n      \"orderby\": [],\n      \"post_processing\": [],\n      \"result_type\": \"\",\n      \"row_limit\": 0,\n      \"row_offset\": 0,\n      \"time_offsets\": [],\n      \"time_range\": \"\",\n      \"time_shift\": \"\",\n      \"timeseries_limit\": 0,\n      \"timeseries_limit_metric\": \"\",\n      \"url_params\": {},\n      \"where\": \"\"\n    }\n  ],\n  \"result_format\": \"\",\n  \"result_type\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "datasource": json!({
            "id": 0,
            "type": ""
        }),
        "force": false,
        "queries": (
            json!({
                "annotation_layers": (
                    json!({
                        "annotationType": "",
                        "color": "",
                        "descriptionColumns": (),
                        "hideLine": false,
                        "intervalEndColumn": "",
                        "name": "",
                        "opacity": "",
                        "overrides": json!({}),
                        "show": false,
                        "showMarkers": false,
                        "sourceType": "",
                        "style": "",
                        "timeColumn": "",
                        "titleColumn": "",
                        "value": "",
                        "width": ""
                    })
                ),
                "applied_time_extras": json!({}),
                "apply_fetch_values_predicate": false,
                "columns": (),
                "datasource": "",
                "druid_time_origin": "",
                "extras": "",
                "filters": (
                    json!({
                        "col": "",
                        "op": "",
                        "val": ""
                    })
                ),
                "granularity": "",
                "granularity_sqla": "",
                "groupby": (),
                "having": "",
                "having_filters": (json!({})),
                "is_rowcount": false,
                "is_timeseries": false,
                "metrics": (),
                "order_desc": false,
                "orderby": (),
                "post_processing": (),
                "result_type": "",
                "row_limit": 0,
                "row_offset": 0,
                "time_offsets": (),
                "time_range": "",
                "time_shift": "",
                "timeseries_limit": 0,
                "timeseries_limit_metric": "",
                "url_params": json!({}),
                "where": ""
            })
        ),
        "result_format": "",
        "result_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);
}

curl --request POST \
  --url {{baseUrl}}/chart/data \
  --header 'content-type: application/json' \
  --data '{
  "datasource": {
    "id": 0,
    "type": ""
  },
  "force": false,
  "queries": [
    {
      "annotation_layers": [
        {
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": {},
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        }
      ],
      "applied_time_extras": {},
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        {
          "col": "",
          "op": "",
          "val": ""
        }
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [
        {}
      ],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": {},
      "where": ""
    }
  ],
  "result_format": "",
  "result_type": ""
}'
echo '{
  "datasource": {
    "id": 0,
    "type": ""
  },
  "force": false,
  "queries": [
    {
      "annotation_layers": [
        {
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": {},
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        }
      ],
      "applied_time_extras": {},
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        {
          "col": "",
          "op": "",
          "val": ""
        }
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [
        {}
      ],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": {},
      "where": ""
    }
  ],
  "result_format": "",
  "result_type": ""
}' |  \
  http POST {{baseUrl}}/chart/data \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "datasource": {\n    "id": 0,\n    "type": ""\n  },\n  "force": false,\n  "queries": [\n    {\n      "annotation_layers": [\n        {\n          "annotationType": "",\n          "color": "",\n          "descriptionColumns": [],\n          "hideLine": false,\n          "intervalEndColumn": "",\n          "name": "",\n          "opacity": "",\n          "overrides": {},\n          "show": false,\n          "showMarkers": false,\n          "sourceType": "",\n          "style": "",\n          "timeColumn": "",\n          "titleColumn": "",\n          "value": "",\n          "width": ""\n        }\n      ],\n      "applied_time_extras": {},\n      "apply_fetch_values_predicate": false,\n      "columns": [],\n      "datasource": "",\n      "druid_time_origin": "",\n      "extras": "",\n      "filters": [\n        {\n          "col": "",\n          "op": "",\n          "val": ""\n        }\n      ],\n      "granularity": "",\n      "granularity_sqla": "",\n      "groupby": [],\n      "having": "",\n      "having_filters": [\n        {}\n      ],\n      "is_rowcount": false,\n      "is_timeseries": false,\n      "metrics": [],\n      "order_desc": false,\n      "orderby": [],\n      "post_processing": [],\n      "result_type": "",\n      "row_limit": 0,\n      "row_offset": 0,\n      "time_offsets": [],\n      "time_range": "",\n      "time_shift": "",\n      "timeseries_limit": 0,\n      "timeseries_limit_metric": "",\n      "url_params": {},\n      "where": ""\n    }\n  ],\n  "result_format": "",\n  "result_type": ""\n}' \
  --output-document \
  - {{baseUrl}}/chart/data
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "datasource": [
    "id": 0,
    "type": ""
  ],
  "force": false,
  "queries": [
    [
      "annotation_layers": [
        [
          "annotationType": "",
          "color": "",
          "descriptionColumns": [],
          "hideLine": false,
          "intervalEndColumn": "",
          "name": "",
          "opacity": "",
          "overrides": [],
          "show": false,
          "showMarkers": false,
          "sourceType": "",
          "style": "",
          "timeColumn": "",
          "titleColumn": "",
          "value": "",
          "width": ""
        ]
      ],
      "applied_time_extras": [],
      "apply_fetch_values_predicate": false,
      "columns": [],
      "datasource": "",
      "druid_time_origin": "",
      "extras": "",
      "filters": [
        [
          "col": "",
          "op": "",
          "val": ""
        ]
      ],
      "granularity": "",
      "granularity_sqla": "",
      "groupby": [],
      "having": "",
      "having_filters": [[]],
      "is_rowcount": false,
      "is_timeseries": false,
      "metrics": [],
      "order_desc": false,
      "orderby": [],
      "post_processing": [],
      "result_type": "",
      "row_limit": 0,
      "row_offset": 0,
      "time_offsets": [],
      "time_range": "",
      "time_shift": "",
      "timeseries_limit": 0,
      "timeseries_limit_metric": "",
      "url_params": [],
      "where": ""
    ]
  ],
  "result_format": "",
  "result_type": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/data")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()
POST post -chart-import-
{{baseUrl}}/chart/import/
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

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

(client/post "{{baseUrl}}/chart/import/" {:multipart [{:name "formData"
                                                                       :content ""} {:name "overwrite"
                                                                       :content ""} {:name "passwords"
                                                                       :content ""}]})
require "http/client"

url = "{{baseUrl}}/chart/import/"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/chart/import/"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "formData",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "overwrite",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "passwords",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/chart/import/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/chart/import/"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

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

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

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

}
POST /baseUrl/chart/import/ HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 287

-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/chart/import/")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/chart/import/"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/chart/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/chart/import/")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('formData', '');
data.append('overwrite', '');
data.append('passwords', '');

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

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

xhr.open('POST', '{{baseUrl}}/chart/import/');

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

const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/chart/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/chart/import/';
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/chart/import/',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

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

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/chart/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

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

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/chart/import/',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/chart/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {formData: '', overwrite: '', passwords: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/chart/import/');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/chart/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

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

const formData = new FormData();
formData.append('formData', '');
formData.append('overwrite', '');
formData.append('passwords', '');

const url = '{{baseUrl}}/chart/import/';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"formData", @"value": @"" },
                         @{ @"name": @"overwrite", @"value": @"" },
                         @{ @"name": @"passwords", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/chart/import/"]
                                                       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}}/chart/import/" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/chart/import/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/chart/import/', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/chart/import/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
');

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

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

$request->setRequestUrl('{{baseUrl}}/chart/import/');
$request->setRequestMethod('POST');
$request->setBody($body);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/chart/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/chart/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
import http.client

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

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

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

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

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

url = "{{baseUrl}}/chart/import/"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

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

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

url <- "{{baseUrl}}/chart/import/"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

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

url = URI("{{baseUrl}}/chart/import/")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/chart/import/') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use reqwest;

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

    let form = reqwest::multipart::Form::new()
        .text("formData", "")
        .text("overwrite", "")
        .text("passwords", "");
    let mut headers = reqwest::header::HeaderMap::new();

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/chart/import/ \
  --header 'content-type: multipart/form-data' \
  --form formData= \
  --form overwrite= \
  --form passwords=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/chart/import/ \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/chart/import/
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "formData",
    "value": ""
  ],
  [
    "name": "overwrite",
    "value": ""
  ],
  [
    "name": "passwords",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/chart/import/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()
POST Create a CSS template
{{baseUrl}}/css_template/
BODY json
{
  "css": "",
  "template_name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

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

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

(client/post "{{baseUrl}}/css_template/" {:content-type :json
                                                          :form-params {:css ""
                                                                        :template_name ""}})
require "http/client"

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

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

func main() {

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

	payload := strings.NewReader("{\n  \"css\": \"\",\n  \"template_name\": \"\"\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/css_template/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/css_template/")
  .header("content-type", "application/json")
  .body("{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  css: '',
  template_name: ''
});

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

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

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

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

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"css":"","template_name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/css_template/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "css": "",\n  "template_name": ""\n}'
};

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

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

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

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

req.type('json');
req.send({
  css: '',
  template_name: ''
});

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}}/css_template/',
  headers: {'content-type': 'application/json'},
  data: {css: '', template_name: ''}
};

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

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

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

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

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/",
  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([
    'css' => '',
    'template_name' => ''
  ]),
  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}}/css_template/', [
  'body' => '{
  "css": "",
  "template_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'css' => '',
  'template_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/css_template/');
$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}}/css_template/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "template_name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "template_name": ""
}'
import http.client

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

payload = "{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}"

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

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

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

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

url = "{{baseUrl}}/css_template/"

payload = {
    "css": "",
    "template_name": ""
}
headers = {"content-type": "application/json"}

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

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

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

payload <- "{\n  \"css\": \"\",\n  \"template_name\": \"\"\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}}/css_template/")

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  \"css\": \"\",\n  \"template_name\": \"\"\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/css_template/') do |req|
  req.body = "{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/css_template/";

    let payload = json!({
        "css": "",
        "template_name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/css_template/ \
  --header 'content-type: application/json' \
  --data '{
  "css": "",
  "template_name": ""
}'
echo '{
  "css": "",
  "template_name": ""
}' |  \
  http POST {{baseUrl}}/css_template/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "css": "",\n  "template_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/css_template/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "css": "",
  "template_name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete CSS template
{{baseUrl}}/css_template/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/css_template/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/css_template/:pk")
require "http/client"

url = "{{baseUrl}}/css_template/:pk"

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}}/css_template/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/css_template/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/css_template/:pk"

	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/css_template/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/css_template/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/css_template/:pk"))
    .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}}/css_template/:pk")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/css_template/:pk")
  .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}}/css_template/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/css_template/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/:pk';
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}}/css_template/:pk',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/css_template/:pk")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/css_template/:pk',
  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}}/css_template/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/css_template/:pk');

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}}/css_template/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/css_template/:pk';
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}}/css_template/:pk"]
                                                       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}}/css_template/:pk" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/:pk",
  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}}/css_template/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/:pk');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/css_template/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/css_template/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/:pk' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/css_template/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/css_template/:pk"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/css_template/:pk"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/css_template/:pk")

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/css_template/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/css_template/:pk";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/css_template/:pk
http DELETE {{baseUrl}}/css_template/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/css_template/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/:pk")! 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()
DELETE Deletes multiple css templates in a bulk operation.
{{baseUrl}}/css_template/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/css_template/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/css_template/")
require "http/client"

url = "{{baseUrl}}/css_template/"

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}}/css_template/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/css_template/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/css_template/"

	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/css_template/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/css_template/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/css_template/"))
    .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}}/css_template/")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/css_template/")
  .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}}/css_template/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/css_template/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/';
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}}/css_template/',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/css_template/")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/css_template/',
  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}}/css_template/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/css_template/');

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}}/css_template/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/css_template/';
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}}/css_template/"]
                                                       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}}/css_template/" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/",
  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}}/css_template/');

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/css_template/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/css_template/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/css_template/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/css_template/"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/css_template/"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/css_template/")

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/css_template/') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/css_template/";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/css_template/
http DELETE {{baseUrl}}/css_template/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/css_template/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/")! 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()
GET Get a CSS template
{{baseUrl}}/css_template/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/css_template/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/css_template/:pk")
require "http/client"

url = "{{baseUrl}}/css_template/:pk"

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}}/css_template/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/css_template/:pk");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/css_template/:pk"

	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/css_template/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/css_template/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/css_template/:pk"))
    .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}}/css_template/:pk")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/css_template/:pk")
  .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}}/css_template/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/css_template/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/:pk';
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}}/css_template/:pk',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/css_template/:pk")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/css_template/:pk',
  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}}/css_template/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/css_template/:pk');

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}}/css_template/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/css_template/:pk';
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}}/css_template/:pk"]
                                                       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}}/css_template/:pk" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/:pk",
  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}}/css_template/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/:pk');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/css_template/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/css_template/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/:pk' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/css_template/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/css_template/:pk"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/css_template/:pk"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/css_template/:pk")

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/css_template/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/css_template/:pk";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/css_template/:pk
http GET {{baseUrl}}/css_template/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/css_template/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
GET Get a list of CSS templates, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/css_template/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/css_template/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/css_template/")
require "http/client"

url = "{{baseUrl}}/css_template/"

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}}/css_template/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/css_template/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/css_template/"

	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/css_template/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/css_template/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/css_template/"))
    .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}}/css_template/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/css_template/")
  .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}}/css_template/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/css_template/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/';
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}}/css_template/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/css_template/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/css_template/',
  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}}/css_template/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/css_template/');

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}}/css_template/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/css_template/';
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}}/css_template/"]
                                                       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}}/css_template/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/",
  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}}/css_template/');

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/css_template/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/css_template/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/css_template/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/css_template/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/css_template/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/css_template/")

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/css_template/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/css_template/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/css_template/
http GET {{baseUrl}}/css_template/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/css_template/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get metadata information about this API resource (GET)
{{baseUrl}}/css_template/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/css_template/_info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/css_template/_info")
require "http/client"

url = "{{baseUrl}}/css_template/_info"

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}}/css_template/_info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/css_template/_info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/css_template/_info"

	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/css_template/_info HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/css_template/_info")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/css_template/_info"))
    .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}}/css_template/_info")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/css_template/_info")
  .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}}/css_template/_info');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/css_template/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/_info';
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}}/css_template/_info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/css_template/_info")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/css_template/_info',
  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}}/css_template/_info'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/css_template/_info');

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}}/css_template/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/css_template/_info';
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}}/css_template/_info"]
                                                       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}}/css_template/_info" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/_info",
  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}}/css_template/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/_info');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/css_template/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/css_template/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/_info' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/css_template/_info")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/css_template/_info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/css_template/_info"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/css_template/_info")

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/css_template/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/css_template/_info";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/css_template/_info
http GET {{baseUrl}}/css_template/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/css_template/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/_info")! 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()
PUT Update a CSS template
{{baseUrl}}/css_template/:pk
QUERY PARAMS
pk
BODY json
{
  "css": "",
  "template_name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/css_template/:pk");

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  \"css\": \"\",\n  \"template_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/css_template/:pk" {:content-type :json
                                                            :form-params {:css ""
                                                                          :template_name ""}})
require "http/client"

url = "{{baseUrl}}/css_template/:pk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"css\": \"\",\n  \"template_name\": \"\"\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}}/css_template/:pk"),
    Content = new StringContent("{\n  \"css\": \"\",\n  \"template_name\": \"\"\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}}/css_template/:pk");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/css_template/:pk"

	payload := strings.NewReader("{\n  \"css\": \"\",\n  \"template_name\": \"\"\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/css_template/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "css": "",
  "template_name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/css_template/:pk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/css_template/:pk"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"css\": \"\",\n  \"template_name\": \"\"\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  \"css\": \"\",\n  \"template_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/css_template/:pk")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/css_template/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  css: '',
  template_name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/css_template/:pk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/css_template/:pk',
  headers: {'content-type': 'application/json'},
  data: {css: '', template_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"css":"","template_name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/css_template/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "css": "",\n  "template_name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/css_template/:pk")
  .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/css_template/:pk',
  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({css: '', template_name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/css_template/:pk',
  headers: {'content-type': 'application/json'},
  body: {css: '', template_name: ''},
  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}}/css_template/:pk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  css: '',
  template_name: ''
});

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}}/css_template/:pk',
  headers: {'content-type': 'application/json'},
  data: {css: '', template_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/css_template/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"css":"","template_name":""}'
};

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 = @{ @"css": @"",
                              @"template_name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/css_template/:pk"]
                                                       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}}/css_template/:pk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/:pk",
  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([
    'css' => '',
    'template_name' => ''
  ]),
  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}}/css_template/:pk', [
  'body' => '{
  "css": "",
  "template_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/:pk');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'css' => '',
  'template_name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'css' => '',
  'template_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/css_template/:pk');
$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}}/css_template/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "template_name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "template_name": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"css\": \"\",\n  \"template_name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/css_template/:pk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/css_template/:pk"

payload = {
    "css": "",
    "template_name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/css_template/:pk"

payload <- "{\n  \"css\": \"\",\n  \"template_name\": \"\"\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}}/css_template/:pk")

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  \"css\": \"\",\n  \"template_name\": \"\"\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/css_template/:pk') do |req|
  req.body = "{\n  \"css\": \"\",\n  \"template_name\": \"\"\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}}/css_template/:pk";

    let payload = json!({
        "css": "",
        "template_name": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/css_template/:pk \
  --header 'content-type: application/json' \
  --data '{
  "css": "",
  "template_name": ""
}'
echo '{
  "css": "",
  "template_name": ""
}' |  \
  http PUT {{baseUrl}}/css_template/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "css": "",\n  "template_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/css_template/:pk
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "css": "",
  "template_name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/:pk")! 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()
GET get -css_template-related--column_name
{{baseUrl}}/css_template/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/css_template/related/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/css_template/related/:column_name")
require "http/client"

url = "{{baseUrl}}/css_template/related/:column_name"

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}}/css_template/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/css_template/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/css_template/related/:column_name"

	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/css_template/related/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/css_template/related/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/css_template/related/:column_name"))
    .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}}/css_template/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/css_template/related/:column_name")
  .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}}/css_template/related/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/css_template/related/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/css_template/related/:column_name';
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}}/css_template/related/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/css_template/related/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/css_template/related/:column_name',
  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}}/css_template/related/:column_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/css_template/related/:column_name');

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}}/css_template/related/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/css_template/related/:column_name';
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}}/css_template/related/:column_name"]
                                                       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}}/css_template/related/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/css_template/related/:column_name",
  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}}/css_template/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/css_template/related/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/css_template/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/css_template/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/css_template/related/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/css_template/related/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/css_template/related/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/css_template/related/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/css_template/related/:column_name")

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/css_template/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/css_template/related/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/css_template/related/:column_name
http GET {{baseUrl}}/css_template/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/css_template/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/css_template/related/:column_name")! 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()
PUT Changes a Dashboard.
{{baseUrl}}/dashboard/:pk
QUERY PARAMS
pk
BODY json
{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/:pk");

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  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/dashboard/:pk" {:content-type :json
                                                         :form-params {:css ""
                                                                       :dashboard_title ""
                                                                       :json_metadata ""
                                                                       :owners []
                                                                       :position_json ""
                                                                       :published false
                                                                       :roles []
                                                                       :slug ""}})
require "http/client"

url = "{{baseUrl}}/dashboard/:pk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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}}/dashboard/:pk"),
    Content = new StringContent("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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}}/dashboard/:pk");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/:pk"

	payload := strings.NewReader("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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/dashboard/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/dashboard/:pk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/:pk"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dashboard/:pk")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/dashboard/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  css: '',
  dashboard_title: '',
  json_metadata: '',
  owners: [],
  position_json: '',
  published: false,
  roles: [],
  slug: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/dashboard/:pk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/dashboard/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    css: '',
    dashboard_title: '',
    json_metadata: '',
    owners: [],
    position_json: '',
    published: false,
    roles: [],
    slug: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"css":"","dashboard_title":"","json_metadata":"","owners":[],"position_json":"","published":false,"roles":[],"slug":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dashboard/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "css": "",\n  "dashboard_title": "",\n  "json_metadata": "",\n  "owners": [],\n  "position_json": "",\n  "published": false,\n  "roles": [],\n  "slug": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/:pk")
  .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/dashboard/:pk',
  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({
  css: '',
  dashboard_title: '',
  json_metadata: '',
  owners: [],
  position_json: '',
  published: false,
  roles: [],
  slug: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/dashboard/:pk',
  headers: {'content-type': 'application/json'},
  body: {
    css: '',
    dashboard_title: '',
    json_metadata: '',
    owners: [],
    position_json: '',
    published: false,
    roles: [],
    slug: ''
  },
  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}}/dashboard/:pk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  css: '',
  dashboard_title: '',
  json_metadata: '',
  owners: [],
  position_json: '',
  published: false,
  roles: [],
  slug: ''
});

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}}/dashboard/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    css: '',
    dashboard_title: '',
    json_metadata: '',
    owners: [],
    position_json: '',
    published: false,
    roles: [],
    slug: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"css":"","dashboard_title":"","json_metadata":"","owners":[],"position_json":"","published":false,"roles":[],"slug":""}'
};

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 = @{ @"css": @"",
                              @"dashboard_title": @"",
                              @"json_metadata": @"",
                              @"owners": @[  ],
                              @"position_json": @"",
                              @"published": @NO,
                              @"roles": @[  ],
                              @"slug": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dashboard/:pk"]
                                                       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}}/dashboard/:pk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/:pk",
  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([
    'css' => '',
    'dashboard_title' => '',
    'json_metadata' => '',
    'owners' => [
        
    ],
    'position_json' => '',
    'published' => null,
    'roles' => [
        
    ],
    'slug' => ''
  ]),
  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}}/dashboard/:pk', [
  'body' => '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/:pk');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'css' => '',
  'dashboard_title' => '',
  'json_metadata' => '',
  'owners' => [
    
  ],
  'position_json' => '',
  'published' => null,
  'roles' => [
    
  ],
  'slug' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'css' => '',
  'dashboard_title' => '',
  'json_metadata' => '',
  'owners' => [
    
  ],
  'position_json' => '',
  'published' => null,
  'roles' => [
    
  ],
  'slug' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dashboard/:pk');
$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}}/dashboard/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/dashboard/:pk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/:pk"

payload = {
    "css": "",
    "dashboard_title": "",
    "json_metadata": "",
    "owners": [],
    "position_json": "",
    "published": False,
    "roles": [],
    "slug": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/:pk"

payload <- "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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}}/dashboard/:pk")

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  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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/dashboard/:pk') do |req|
  req.body = "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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}}/dashboard/:pk";

    let payload = json!({
        "css": "",
        "dashboard_title": "",
        "json_metadata": "",
        "owners": (),
        "position_json": "",
        "published": false,
        "roles": (),
        "slug": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/dashboard/:pk \
  --header 'content-type: application/json' \
  --data '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}'
echo '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}' |  \
  http PUT {{baseUrl}}/dashboard/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "css": "",\n  "dashboard_title": "",\n  "json_metadata": "",\n  "owners": [],\n  "position_json": "",\n  "published": false,\n  "roles": [],\n  "slug": ""\n}' \
  --output-document \
  - {{baseUrl}}/dashboard/:pk
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/:pk")! 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()
GET Check favorited dashboards for current user (GET)
{{baseUrl}}/dashboard/favorite_status/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/favorite_status/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/favorite_status/")
require "http/client"

url = "{{baseUrl}}/dashboard/favorite_status/"

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}}/dashboard/favorite_status/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/favorite_status/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/favorite_status/"

	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/dashboard/favorite_status/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/favorite_status/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/favorite_status/"))
    .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}}/dashboard/favorite_status/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/favorite_status/")
  .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}}/dashboard/favorite_status/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dashboard/favorite_status/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/favorite_status/';
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}}/dashboard/favorite_status/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/favorite_status/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/favorite_status/',
  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}}/dashboard/favorite_status/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/favorite_status/');

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}}/dashboard/favorite_status/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/favorite_status/';
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}}/dashboard/favorite_status/"]
                                                       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}}/dashboard/favorite_status/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/favorite_status/",
  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}}/dashboard/favorite_status/');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/favorite_status/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/favorite_status/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/favorite_status/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/favorite_status/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/favorite_status/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/favorite_status/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/favorite_status/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/favorite_status/")

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/dashboard/favorite_status/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/favorite_status/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/favorite_status/
http GET {{baseUrl}}/dashboard/favorite_status/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/favorite_status/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/favorite_status/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Compute async or get already computed dashboard thumbnail from cache.
{{baseUrl}}/dashboard/:pk/thumbnail/:digest/
QUERY PARAMS
pk
digest
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/")
require "http/client"

url = "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/"

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}}/dashboard/:pk/thumbnail/:digest/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/:pk/thumbnail/:digest/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/"

	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/dashboard/:pk/thumbnail/:digest/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/:pk/thumbnail/:digest/"))
    .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}}/dashboard/:pk/thumbnail/:digest/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/:pk/thumbnail/:digest/")
  .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}}/dashboard/:pk/thumbnail/:digest/');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/dashboard/:pk/thumbnail/:digest/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/:pk/thumbnail/:digest/';
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}}/dashboard/:pk/thumbnail/:digest/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/:pk/thumbnail/:digest/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/:pk/thumbnail/:digest/',
  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}}/dashboard/:pk/thumbnail/:digest/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/:pk/thumbnail/:digest/');

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}}/dashboard/:pk/thumbnail/:digest/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/:pk/thumbnail/:digest/';
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}}/dashboard/:pk/thumbnail/:digest/"]
                                                       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}}/dashboard/:pk/thumbnail/:digest/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/",
  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}}/dashboard/:pk/thumbnail/:digest/');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/:pk/thumbnail/:digest/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/:pk/thumbnail/:digest/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/:pk/thumbnail/:digest/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/:pk/thumbnail/:digest/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/:pk/thumbnail/:digest/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/:pk/thumbnail/:digest/")

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/dashboard/:pk/thumbnail/:digest/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/:pk/thumbnail/:digest/
http GET {{baseUrl}}/dashboard/:pk/thumbnail/:digest/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/:pk/thumbnail/:digest/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/:pk/thumbnail/:digest/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a new Dashboard.
{{baseUrl}}/dashboard/
BODY json
{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/");

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  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/dashboard/" {:content-type :json
                                                       :form-params {:css ""
                                                                     :dashboard_title ""
                                                                     :json_metadata ""
                                                                     :owners []
                                                                     :position_json ""
                                                                     :published false
                                                                     :roles []
                                                                     :slug ""}})
require "http/client"

url = "{{baseUrl}}/dashboard/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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}}/dashboard/"),
    Content = new StringContent("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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}}/dashboard/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/"

	payload := strings.NewReader("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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/dashboard/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 153

{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dashboard/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dashboard/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/dashboard/")
  .header("content-type", "application/json")
  .body("{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  css: '',
  dashboard_title: '',
  json_metadata: '',
  owners: [],
  position_json: '',
  published: false,
  roles: [],
  slug: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/dashboard/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dashboard/',
  headers: {'content-type': 'application/json'},
  data: {
    css: '',
    dashboard_title: '',
    json_metadata: '',
    owners: [],
    position_json: '',
    published: false,
    roles: [],
    slug: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"css":"","dashboard_title":"","json_metadata":"","owners":[],"position_json":"","published":false,"roles":[],"slug":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dashboard/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "css": "",\n  "dashboard_title": "",\n  "json_metadata": "",\n  "owners": [],\n  "position_json": "",\n  "published": false,\n  "roles": [],\n  "slug": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/")
  .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/dashboard/',
  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({
  css: '',
  dashboard_title: '',
  json_metadata: '',
  owners: [],
  position_json: '',
  published: false,
  roles: [],
  slug: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dashboard/',
  headers: {'content-type': 'application/json'},
  body: {
    css: '',
    dashboard_title: '',
    json_metadata: '',
    owners: [],
    position_json: '',
    published: false,
    roles: [],
    slug: ''
  },
  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}}/dashboard/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  css: '',
  dashboard_title: '',
  json_metadata: '',
  owners: [],
  position_json: '',
  published: false,
  roles: [],
  slug: ''
});

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}}/dashboard/',
  headers: {'content-type': 'application/json'},
  data: {
    css: '',
    dashboard_title: '',
    json_metadata: '',
    owners: [],
    position_json: '',
    published: false,
    roles: [],
    slug: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"css":"","dashboard_title":"","json_metadata":"","owners":[],"position_json":"","published":false,"roles":[],"slug":""}'
};

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 = @{ @"css": @"",
                              @"dashboard_title": @"",
                              @"json_metadata": @"",
                              @"owners": @[  ],
                              @"position_json": @"",
                              @"published": @NO,
                              @"roles": @[  ],
                              @"slug": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dashboard/"]
                                                       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}}/dashboard/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/",
  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([
    'css' => '',
    'dashboard_title' => '',
    'json_metadata' => '',
    'owners' => [
        
    ],
    'position_json' => '',
    'published' => null,
    'roles' => [
        
    ],
    'slug' => ''
  ]),
  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}}/dashboard/', [
  'body' => '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'css' => '',
  'dashboard_title' => '',
  'json_metadata' => '',
  'owners' => [
    
  ],
  'position_json' => '',
  'published' => null,
  'roles' => [
    
  ],
  'slug' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'css' => '',
  'dashboard_title' => '',
  'json_metadata' => '',
  'owners' => [
    
  ],
  'position_json' => '',
  'published' => null,
  'roles' => [
    
  ],
  'slug' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dashboard/');
$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}}/dashboard/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/dashboard/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/"

payload = {
    "css": "",
    "dashboard_title": "",
    "json_metadata": "",
    "owners": [],
    "position_json": "",
    "published": False,
    "roles": [],
    "slug": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/"

payload <- "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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}}/dashboard/")

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  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\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/dashboard/') do |req|
  req.body = "{\n  \"css\": \"\",\n  \"dashboard_title\": \"\",\n  \"json_metadata\": \"\",\n  \"owners\": [],\n  \"position_json\": \"\",\n  \"published\": false,\n  \"roles\": [],\n  \"slug\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/";

    let payload = json!({
        "css": "",
        "dashboard_title": "",
        "json_metadata": "",
        "owners": (),
        "position_json": "",
        "published": false,
        "roles": (),
        "slug": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/dashboard/ \
  --header 'content-type: application/json' \
  --data '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}'
echo '{
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
}' |  \
  http POST {{baseUrl}}/dashboard/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "css": "",\n  "dashboard_title": "",\n  "json_metadata": "",\n  "owners": [],\n  "position_json": "",\n  "published": false,\n  "roles": [],\n  "slug": ""\n}' \
  --output-document \
  - {{baseUrl}}/dashboard/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "css": "",
  "dashboard_title": "",
  "json_metadata": "",
  "owners": [],
  "position_json": "",
  "published": false,
  "roles": [],
  "slug": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Deletes a Dashboard.
{{baseUrl}}/dashboard/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dashboard/:pk")
require "http/client"

url = "{{baseUrl}}/dashboard/:pk"

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}}/dashboard/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/:pk"

	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/dashboard/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dashboard/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/:pk"))
    .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}}/dashboard/:pk")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/dashboard/:pk")
  .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}}/dashboard/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/dashboard/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/:pk';
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}}/dashboard/:pk',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/:pk")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/:pk',
  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}}/dashboard/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dashboard/:pk');

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}}/dashboard/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/:pk';
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}}/dashboard/:pk"]
                                                       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}}/dashboard/:pk" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/:pk",
  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}}/dashboard/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/:pk');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/:pk' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dashboard/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/:pk"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/:pk"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/:pk")

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/dashboard/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/:pk";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/dashboard/:pk
http DELETE {{baseUrl}}/dashboard/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dashboard/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/:pk")! 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()
DELETE Deletes multiple Dashboards in a bulk operation.
{{baseUrl}}/dashboard/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dashboard/")
require "http/client"

url = "{{baseUrl}}/dashboard/"

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}}/dashboard/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/"

	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/dashboard/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dashboard/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/"))
    .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}}/dashboard/")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/dashboard/")
  .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}}/dashboard/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/dashboard/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/';
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}}/dashboard/',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/',
  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}}/dashboard/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dashboard/');

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}}/dashboard/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/';
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}}/dashboard/"]
                                                       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}}/dashboard/" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/",
  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}}/dashboard/');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dashboard/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/")

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/dashboard/') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/dashboard/
http DELETE {{baseUrl}}/dashboard/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dashboard/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/")! 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()
GET Exports multiple Dashboards and downloads them as YAML files.
{{baseUrl}}/dashboard/export/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/export/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/export/")
require "http/client"

url = "{{baseUrl}}/dashboard/export/"

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}}/dashboard/export/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/export/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/export/"

	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/dashboard/export/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/export/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/export/"))
    .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}}/dashboard/export/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/export/")
  .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}}/dashboard/export/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dashboard/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/export/';
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}}/dashboard/export/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/export/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/export/',
  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}}/dashboard/export/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/export/');

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}}/dashboard/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/export/';
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}}/dashboard/export/"]
                                                       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}}/dashboard/export/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/export/",
  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}}/dashboard/export/');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/export/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/export/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/export/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/export/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/export/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/export/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/export/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/export/")

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/dashboard/export/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/export/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/export/
http GET {{baseUrl}}/dashboard/export/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/export/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/export/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a dashboard detail information.
{{baseUrl}}/dashboard/:id_or_slug
QUERY PARAMS
id_or_slug
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/:id_or_slug");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/:id_or_slug")
require "http/client"

url = "{{baseUrl}}/dashboard/:id_or_slug"

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}}/dashboard/:id_or_slug"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/:id_or_slug");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/:id_or_slug"

	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/dashboard/:id_or_slug HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/:id_or_slug")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/:id_or_slug"))
    .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}}/dashboard/:id_or_slug")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/:id_or_slug")
  .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}}/dashboard/:id_or_slug');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dashboard/:id_or_slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/:id_or_slug';
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}}/dashboard/:id_or_slug',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/:id_or_slug")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/:id_or_slug',
  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}}/dashboard/:id_or_slug'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/:id_or_slug');

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}}/dashboard/:id_or_slug'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/:id_or_slug';
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}}/dashboard/:id_or_slug"]
                                                       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}}/dashboard/:id_or_slug" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/:id_or_slug",
  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}}/dashboard/:id_or_slug');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/:id_or_slug');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/:id_or_slug');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/:id_or_slug' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/:id_or_slug' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/:id_or_slug")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/:id_or_slug"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/:id_or_slug"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/:id_or_slug")

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/dashboard/:id_or_slug') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/:id_or_slug";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/:id_or_slug
http GET {{baseUrl}}/dashboard/:id_or_slug
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/:id_or_slug
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/:id_or_slug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a list of all possible owners for a dashboard.
{{baseUrl}}/dashboard/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/related/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/related/:column_name")
require "http/client"

url = "{{baseUrl}}/dashboard/related/:column_name"

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}}/dashboard/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/related/:column_name"

	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/dashboard/related/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/related/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/related/:column_name"))
    .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}}/dashboard/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/related/:column_name")
  .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}}/dashboard/related/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/dashboard/related/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/related/:column_name';
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}}/dashboard/related/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/related/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/related/:column_name',
  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}}/dashboard/related/:column_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/related/:column_name');

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}}/dashboard/related/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/related/:column_name';
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}}/dashboard/related/:column_name"]
                                                       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}}/dashboard/related/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/related/:column_name",
  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}}/dashboard/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/related/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/related/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/related/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/related/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/related/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/related/:column_name")

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/dashboard/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/related/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/related/:column_name
http GET {{baseUrl}}/dashboard/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/related/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a list of dashboards, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/dashboard/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/")
require "http/client"

url = "{{baseUrl}}/dashboard/"

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}}/dashboard/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/"

	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/dashboard/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/"))
    .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}}/dashboard/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/")
  .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}}/dashboard/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dashboard/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/';
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}}/dashboard/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/',
  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}}/dashboard/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/');

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}}/dashboard/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/';
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}}/dashboard/"]
                                                       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}}/dashboard/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/",
  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}}/dashboard/');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/")

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/dashboard/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/
http GET {{baseUrl}}/dashboard/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get the chart definitions for a given dashboard
{{baseUrl}}/dashboard/:id_or_slug/charts
QUERY PARAMS
id_or_slug
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/:id_or_slug/charts");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/:id_or_slug/charts")
require "http/client"

url = "{{baseUrl}}/dashboard/:id_or_slug/charts"

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}}/dashboard/:id_or_slug/charts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/:id_or_slug/charts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/:id_or_slug/charts"

	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/dashboard/:id_or_slug/charts HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/:id_or_slug/charts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/:id_or_slug/charts"))
    .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}}/dashboard/:id_or_slug/charts")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/:id_or_slug/charts")
  .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}}/dashboard/:id_or_slug/charts');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dashboard/:id_or_slug/charts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/:id_or_slug/charts';
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}}/dashboard/:id_or_slug/charts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/:id_or_slug/charts")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/:id_or_slug/charts',
  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}}/dashboard/:id_or_slug/charts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/:id_or_slug/charts');

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}}/dashboard/:id_or_slug/charts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/:id_or_slug/charts';
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}}/dashboard/:id_or_slug/charts"]
                                                       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}}/dashboard/:id_or_slug/charts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/:id_or_slug/charts",
  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}}/dashboard/:id_or_slug/charts');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/:id_or_slug/charts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/:id_or_slug/charts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/:id_or_slug/charts' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/:id_or_slug/charts' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/:id_or_slug/charts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/:id_or_slug/charts"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/:id_or_slug/charts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/:id_or_slug/charts")

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/dashboard/:id_or_slug/charts') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/:id_or_slug/charts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/:id_or_slug/charts
http GET {{baseUrl}}/dashboard/:id_or_slug/charts
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/:id_or_slug/charts
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/:id_or_slug/charts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Returns a list of a dashboard's datasets. Each dataset includes only the information necessary to render the dashboard's charts.
{{baseUrl}}/dashboard/:id_or_slug/datasets
QUERY PARAMS
id_or_slug
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/:id_or_slug/datasets");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/:id_or_slug/datasets")
require "http/client"

url = "{{baseUrl}}/dashboard/:id_or_slug/datasets"

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}}/dashboard/:id_or_slug/datasets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/:id_or_slug/datasets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/:id_or_slug/datasets"

	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/dashboard/:id_or_slug/datasets HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/:id_or_slug/datasets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/:id_or_slug/datasets"))
    .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}}/dashboard/:id_or_slug/datasets")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/:id_or_slug/datasets")
  .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}}/dashboard/:id_or_slug/datasets');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/dashboard/:id_or_slug/datasets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/:id_or_slug/datasets';
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}}/dashboard/:id_or_slug/datasets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/:id_or_slug/datasets")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/:id_or_slug/datasets',
  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}}/dashboard/:id_or_slug/datasets'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/:id_or_slug/datasets');

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}}/dashboard/:id_or_slug/datasets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/:id_or_slug/datasets';
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}}/dashboard/:id_or_slug/datasets"]
                                                       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}}/dashboard/:id_or_slug/datasets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/:id_or_slug/datasets",
  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}}/dashboard/:id_or_slug/datasets');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/:id_or_slug/datasets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/:id_or_slug/datasets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/:id_or_slug/datasets' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/:id_or_slug/datasets' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/:id_or_slug/datasets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/:id_or_slug/datasets"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/:id_or_slug/datasets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/:id_or_slug/datasets")

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/dashboard/:id_or_slug/datasets') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/:id_or_slug/datasets";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/:id_or_slug/datasets
http GET {{baseUrl}}/dashboard/:id_or_slug/datasets
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/:id_or_slug/datasets
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/:id_or_slug/datasets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Several metadata information about dashboard API endpoints.
{{baseUrl}}/dashboard/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/_info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboard/_info")
require "http/client"

url = "{{baseUrl}}/dashboard/_info"

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}}/dashboard/_info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/_info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/_info"

	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/dashboard/_info HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboard/_info")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/_info"))
    .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}}/dashboard/_info")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dashboard/_info")
  .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}}/dashboard/_info');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dashboard/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/_info';
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}}/dashboard/_info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/_info")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/_info',
  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}}/dashboard/_info'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboard/_info');

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}}/dashboard/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboard/_info';
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}}/dashboard/_info"]
                                                       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}}/dashboard/_info" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/_info",
  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}}/dashboard/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/_info');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dashboard/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/_info' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboard/_info")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/_info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/_info"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/_info")

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/dashboard/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/_info";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dashboard/_info
http GET {{baseUrl}}/dashboard/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboard/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/_info")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST post -dashboard-import-
{{baseUrl}}/dashboard/import/
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dashboard/import/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/dashboard/import/" {:multipart [{:name "formData"
                                                                           :content ""} {:name "overwrite"
                                                                           :content ""} {:name "passwords"
                                                                           :content ""}]})
require "http/client"

url = "{{baseUrl}}/dashboard/import/"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/dashboard/import/"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "formData",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "overwrite",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "passwords",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dashboard/import/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboard/import/"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/dashboard/import/ HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 287

-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dashboard/import/")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboard/import/"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dashboard/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/dashboard/import/")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('formData', '');
data.append('overwrite', '');
data.append('passwords', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/dashboard/import/');

xhr.send(data);
import axios from 'axios';

const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dashboard/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dashboard/import/';
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dashboard/import/',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/dashboard/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboard/import/',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dashboard/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {formData: '', overwrite: '', passwords: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/dashboard/import/');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/dashboard/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('formData', '');
formData.append('overwrite', '');
formData.append('passwords', '');

const url = '{{baseUrl}}/dashboard/import/';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"formData", @"value": @"" },
                         @{ @"name": @"overwrite", @"value": @"" },
                         @{ @"name": @"passwords", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dashboard/import/"]
                                                       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}}/dashboard/import/" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dashboard/import/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/dashboard/import/', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/dashboard/import/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/dashboard/import/');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboard/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboard/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/dashboard/import/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dashboard/import/"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dashboard/import/"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboard/import/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/dashboard/import/') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboard/import/";

    let form = reqwest::multipart::Form::new()
        .text("formData", "")
        .text("overwrite", "")
        .text("passwords", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/dashboard/import/ \
  --header 'content-type: multipart/form-data' \
  --form formData= \
  --form overwrite= \
  --form passwords=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/dashboard/import/ \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/dashboard/import/
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "formData",
    "value": ""
  ],
  [
    "name": "overwrite",
    "value": ""
  ],
  [
    "name": "passwords",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboard/import/")! 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()
PUT Changes a Database.
{{baseUrl}}/database/:pk
QUERY PARAMS
pk
BODY json
{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk");

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  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/database/:pk" {:content-type :json
                                                        :form-params {:allow_csv_upload false
                                                                      :allow_ctas false
                                                                      :allow_cvas false
                                                                      :allow_dml false
                                                                      :allow_multi_schema_metadata_fetch false
                                                                      :allow_run_async false
                                                                      :cache_timeout 0
                                                                      :configuration_method ""
                                                                      :database_name ""
                                                                      :encrypted_extra ""
                                                                      :engine ""
                                                                      :expose_in_sqllab false
                                                                      :extra ""
                                                                      :force_ctas_schema ""
                                                                      :impersonate_user false
                                                                      :parameters {}
                                                                      :server_cert ""
                                                                      :sqlalchemy_uri ""}})
require "http/client"

url = "{{baseUrl}}/database/:pk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/:pk"),
    Content = new StringContent("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/:pk");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk"

	payload := strings.NewReader("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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/database/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 454

{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/database/:pk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/database/:pk")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/database/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  allow_csv_upload: false,
  allow_ctas: false,
  allow_cvas: false,
  allow_dml: false,
  allow_multi_schema_metadata_fetch: false,
  allow_run_async: false,
  cache_timeout: 0,
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  expose_in_sqllab: false,
  extra: '',
  force_ctas_schema: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/database/:pk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/database/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    allow_csv_upload: false,
    allow_ctas: false,
    allow_cvas: false,
    allow_dml: false,
    allow_multi_schema_metadata_fetch: false,
    allow_run_async: false,
    cache_timeout: 0,
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    expose_in_sqllab: false,
    extra: '',
    force_ctas_schema: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"allow_csv_upload":false,"allow_ctas":false,"allow_cvas":false,"allow_dml":false,"allow_multi_schema_metadata_fetch":false,"allow_run_async":false,"cache_timeout":0,"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","expose_in_sqllab":false,"extra":"","force_ctas_schema":"","impersonate_user":false,"parameters":{},"server_cert":"","sqlalchemy_uri":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/database/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "allow_csv_upload": false,\n  "allow_ctas": false,\n  "allow_cvas": false,\n  "allow_dml": false,\n  "allow_multi_schema_metadata_fetch": false,\n  "allow_run_async": false,\n  "cache_timeout": 0,\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "expose_in_sqllab": false,\n  "extra": "",\n  "force_ctas_schema": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": "",\n  "sqlalchemy_uri": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk")
  .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/database/:pk',
  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({
  allow_csv_upload: false,
  allow_ctas: false,
  allow_cvas: false,
  allow_dml: false,
  allow_multi_schema_metadata_fetch: false,
  allow_run_async: false,
  cache_timeout: 0,
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  expose_in_sqllab: false,
  extra: '',
  force_ctas_schema: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/database/:pk',
  headers: {'content-type': 'application/json'},
  body: {
    allow_csv_upload: false,
    allow_ctas: false,
    allow_cvas: false,
    allow_dml: false,
    allow_multi_schema_metadata_fetch: false,
    allow_run_async: false,
    cache_timeout: 0,
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    expose_in_sqllab: false,
    extra: '',
    force_ctas_schema: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  },
  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}}/database/:pk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  allow_csv_upload: false,
  allow_ctas: false,
  allow_cvas: false,
  allow_dml: false,
  allow_multi_schema_metadata_fetch: false,
  allow_run_async: false,
  cache_timeout: 0,
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  expose_in_sqllab: false,
  extra: '',
  force_ctas_schema: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
});

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}}/database/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    allow_csv_upload: false,
    allow_ctas: false,
    allow_cvas: false,
    allow_dml: false,
    allow_multi_schema_metadata_fetch: false,
    allow_run_async: false,
    cache_timeout: 0,
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    expose_in_sqllab: false,
    extra: '',
    force_ctas_schema: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"allow_csv_upload":false,"allow_ctas":false,"allow_cvas":false,"allow_dml":false,"allow_multi_schema_metadata_fetch":false,"allow_run_async":false,"cache_timeout":0,"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","expose_in_sqllab":false,"extra":"","force_ctas_schema":"","impersonate_user":false,"parameters":{},"server_cert":"","sqlalchemy_uri":""}'
};

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 = @{ @"allow_csv_upload": @NO,
                              @"allow_ctas": @NO,
                              @"allow_cvas": @NO,
                              @"allow_dml": @NO,
                              @"allow_multi_schema_metadata_fetch": @NO,
                              @"allow_run_async": @NO,
                              @"cache_timeout": @0,
                              @"configuration_method": @"",
                              @"database_name": @"",
                              @"encrypted_extra": @"",
                              @"engine": @"",
                              @"expose_in_sqllab": @NO,
                              @"extra": @"",
                              @"force_ctas_schema": @"",
                              @"impersonate_user": @NO,
                              @"parameters": @{  },
                              @"server_cert": @"",
                              @"sqlalchemy_uri": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/database/:pk"]
                                                       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}}/database/:pk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk",
  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([
    'allow_csv_upload' => null,
    'allow_ctas' => null,
    'allow_cvas' => null,
    'allow_dml' => null,
    'allow_multi_schema_metadata_fetch' => null,
    'allow_run_async' => null,
    'cache_timeout' => 0,
    'configuration_method' => '',
    'database_name' => '',
    'encrypted_extra' => '',
    'engine' => '',
    'expose_in_sqllab' => null,
    'extra' => '',
    'force_ctas_schema' => '',
    'impersonate_user' => null,
    'parameters' => [
        
    ],
    'server_cert' => '',
    'sqlalchemy_uri' => ''
  ]),
  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}}/database/:pk', [
  'body' => '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allow_csv_upload' => null,
  'allow_ctas' => null,
  'allow_cvas' => null,
  'allow_dml' => null,
  'allow_multi_schema_metadata_fetch' => null,
  'allow_run_async' => null,
  'cache_timeout' => 0,
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'expose_in_sqllab' => null,
  'extra' => '',
  'force_ctas_schema' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => '',
  'sqlalchemy_uri' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'allow_csv_upload' => null,
  'allow_ctas' => null,
  'allow_cvas' => null,
  'allow_dml' => null,
  'allow_multi_schema_metadata_fetch' => null,
  'allow_run_async' => null,
  'cache_timeout' => 0,
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'expose_in_sqllab' => null,
  'extra' => '',
  'force_ctas_schema' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => '',
  'sqlalchemy_uri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/database/:pk');
$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}}/database/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/database/:pk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk"

payload = {
    "allow_csv_upload": False,
    "allow_ctas": False,
    "allow_cvas": False,
    "allow_dml": False,
    "allow_multi_schema_metadata_fetch": False,
    "allow_run_async": False,
    "cache_timeout": 0,
    "configuration_method": "",
    "database_name": "",
    "encrypted_extra": "",
    "engine": "",
    "expose_in_sqllab": False,
    "extra": "",
    "force_ctas_schema": "",
    "impersonate_user": False,
    "parameters": {},
    "server_cert": "",
    "sqlalchemy_uri": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk"

payload <- "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/:pk")

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  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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/database/:pk') do |req|
  req.body = "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/:pk";

    let payload = json!({
        "allow_csv_upload": false,
        "allow_ctas": false,
        "allow_cvas": false,
        "allow_dml": false,
        "allow_multi_schema_metadata_fetch": false,
        "allow_run_async": false,
        "cache_timeout": 0,
        "configuration_method": "",
        "database_name": "",
        "encrypted_extra": "",
        "engine": "",
        "expose_in_sqllab": false,
        "extra": "",
        "force_ctas_schema": "",
        "impersonate_user": false,
        "parameters": json!({}),
        "server_cert": "",
        "sqlalchemy_uri": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/database/:pk \
  --header 'content-type: application/json' \
  --data '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
echo '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}' |  \
  http PUT {{baseUrl}}/database/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "allow_csv_upload": false,\n  "allow_ctas": false,\n  "allow_cvas": false,\n  "allow_dml": false,\n  "allow_multi_schema_metadata_fetch": false,\n  "allow_run_async": false,\n  "cache_timeout": 0,\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "expose_in_sqllab": false,\n  "extra": "",\n  "force_ctas_schema": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": "",\n  "sqlalchemy_uri": ""\n}' \
  --output-document \
  - {{baseUrl}}/database/:pk
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": [],
  "server_cert": "",
  "sqlalchemy_uri": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk")! 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()
POST Create a new Database.
{{baseUrl}}/database/
BODY json
{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/");

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  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/database/" {:content-type :json
                                                      :form-params {:allow_csv_upload false
                                                                    :allow_ctas false
                                                                    :allow_cvas false
                                                                    :allow_dml false
                                                                    :allow_multi_schema_metadata_fetch false
                                                                    :allow_run_async false
                                                                    :cache_timeout 0
                                                                    :configuration_method ""
                                                                    :database_name ""
                                                                    :encrypted_extra ""
                                                                    :engine ""
                                                                    :expose_in_sqllab false
                                                                    :extra ""
                                                                    :force_ctas_schema ""
                                                                    :impersonate_user false
                                                                    :parameters {}
                                                                    :server_cert ""
                                                                    :sqlalchemy_uri ""}})
require "http/client"

url = "{{baseUrl}}/database/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/"),
    Content = new StringContent("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/"

	payload := strings.NewReader("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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/database/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 454

{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/database/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/database/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/database/")
  .header("content-type", "application/json")
  .body("{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  allow_csv_upload: false,
  allow_ctas: false,
  allow_cvas: false,
  allow_dml: false,
  allow_multi_schema_metadata_fetch: false,
  allow_run_async: false,
  cache_timeout: 0,
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  expose_in_sqllab: false,
  extra: '',
  force_ctas_schema: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/database/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/',
  headers: {'content-type': 'application/json'},
  data: {
    allow_csv_upload: false,
    allow_ctas: false,
    allow_cvas: false,
    allow_dml: false,
    allow_multi_schema_metadata_fetch: false,
    allow_run_async: false,
    cache_timeout: 0,
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    expose_in_sqllab: false,
    extra: '',
    force_ctas_schema: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allow_csv_upload":false,"allow_ctas":false,"allow_cvas":false,"allow_dml":false,"allow_multi_schema_metadata_fetch":false,"allow_run_async":false,"cache_timeout":0,"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","expose_in_sqllab":false,"extra":"","force_ctas_schema":"","impersonate_user":false,"parameters":{},"server_cert":"","sqlalchemy_uri":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/database/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "allow_csv_upload": false,\n  "allow_ctas": false,\n  "allow_cvas": false,\n  "allow_dml": false,\n  "allow_multi_schema_metadata_fetch": false,\n  "allow_run_async": false,\n  "cache_timeout": 0,\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "expose_in_sqllab": false,\n  "extra": "",\n  "force_ctas_schema": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": "",\n  "sqlalchemy_uri": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/database/")
  .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/database/',
  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({
  allow_csv_upload: false,
  allow_ctas: false,
  allow_cvas: false,
  allow_dml: false,
  allow_multi_schema_metadata_fetch: false,
  allow_run_async: false,
  cache_timeout: 0,
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  expose_in_sqllab: false,
  extra: '',
  force_ctas_schema: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/',
  headers: {'content-type': 'application/json'},
  body: {
    allow_csv_upload: false,
    allow_ctas: false,
    allow_cvas: false,
    allow_dml: false,
    allow_multi_schema_metadata_fetch: false,
    allow_run_async: false,
    cache_timeout: 0,
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    expose_in_sqllab: false,
    extra: '',
    force_ctas_schema: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  },
  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}}/database/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  allow_csv_upload: false,
  allow_ctas: false,
  allow_cvas: false,
  allow_dml: false,
  allow_multi_schema_metadata_fetch: false,
  allow_run_async: false,
  cache_timeout: 0,
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  expose_in_sqllab: false,
  extra: '',
  force_ctas_schema: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
});

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}}/database/',
  headers: {'content-type': 'application/json'},
  data: {
    allow_csv_upload: false,
    allow_ctas: false,
    allow_cvas: false,
    allow_dml: false,
    allow_multi_schema_metadata_fetch: false,
    allow_run_async: false,
    cache_timeout: 0,
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    expose_in_sqllab: false,
    extra: '',
    force_ctas_schema: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allow_csv_upload":false,"allow_ctas":false,"allow_cvas":false,"allow_dml":false,"allow_multi_schema_metadata_fetch":false,"allow_run_async":false,"cache_timeout":0,"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","expose_in_sqllab":false,"extra":"","force_ctas_schema":"","impersonate_user":false,"parameters":{},"server_cert":"","sqlalchemy_uri":""}'
};

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 = @{ @"allow_csv_upload": @NO,
                              @"allow_ctas": @NO,
                              @"allow_cvas": @NO,
                              @"allow_dml": @NO,
                              @"allow_multi_schema_metadata_fetch": @NO,
                              @"allow_run_async": @NO,
                              @"cache_timeout": @0,
                              @"configuration_method": @"",
                              @"database_name": @"",
                              @"encrypted_extra": @"",
                              @"engine": @"",
                              @"expose_in_sqllab": @NO,
                              @"extra": @"",
                              @"force_ctas_schema": @"",
                              @"impersonate_user": @NO,
                              @"parameters": @{  },
                              @"server_cert": @"",
                              @"sqlalchemy_uri": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/database/"]
                                                       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}}/database/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/",
  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([
    'allow_csv_upload' => null,
    'allow_ctas' => null,
    'allow_cvas' => null,
    'allow_dml' => null,
    'allow_multi_schema_metadata_fetch' => null,
    'allow_run_async' => null,
    'cache_timeout' => 0,
    'configuration_method' => '',
    'database_name' => '',
    'encrypted_extra' => '',
    'engine' => '',
    'expose_in_sqllab' => null,
    'extra' => '',
    'force_ctas_schema' => '',
    'impersonate_user' => null,
    'parameters' => [
        
    ],
    'server_cert' => '',
    'sqlalchemy_uri' => ''
  ]),
  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}}/database/', [
  'body' => '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/database/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allow_csv_upload' => null,
  'allow_ctas' => null,
  'allow_cvas' => null,
  'allow_dml' => null,
  'allow_multi_schema_metadata_fetch' => null,
  'allow_run_async' => null,
  'cache_timeout' => 0,
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'expose_in_sqllab' => null,
  'extra' => '',
  'force_ctas_schema' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => '',
  'sqlalchemy_uri' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'allow_csv_upload' => null,
  'allow_ctas' => null,
  'allow_cvas' => null,
  'allow_dml' => null,
  'allow_multi_schema_metadata_fetch' => null,
  'allow_run_async' => null,
  'cache_timeout' => 0,
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'expose_in_sqllab' => null,
  'extra' => '',
  'force_ctas_schema' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => '',
  'sqlalchemy_uri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/database/');
$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}}/database/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/database/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/"

payload = {
    "allow_csv_upload": False,
    "allow_ctas": False,
    "allow_cvas": False,
    "allow_dml": False,
    "allow_multi_schema_metadata_fetch": False,
    "allow_run_async": False,
    "cache_timeout": 0,
    "configuration_method": "",
    "database_name": "",
    "encrypted_extra": "",
    "engine": "",
    "expose_in_sqllab": False,
    "extra": "",
    "force_ctas_schema": "",
    "impersonate_user": False,
    "parameters": {},
    "server_cert": "",
    "sqlalchemy_uri": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/"

payload <- "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/")

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  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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/database/') do |req|
  req.body = "{\n  \"allow_csv_upload\": false,\n  \"allow_ctas\": false,\n  \"allow_cvas\": false,\n  \"allow_dml\": false,\n  \"allow_multi_schema_metadata_fetch\": false,\n  \"allow_run_async\": false,\n  \"cache_timeout\": 0,\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"expose_in_sqllab\": false,\n  \"extra\": \"\",\n  \"force_ctas_schema\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/";

    let payload = json!({
        "allow_csv_upload": false,
        "allow_ctas": false,
        "allow_cvas": false,
        "allow_dml": false,
        "allow_multi_schema_metadata_fetch": false,
        "allow_run_async": false,
        "cache_timeout": 0,
        "configuration_method": "",
        "database_name": "",
        "encrypted_extra": "",
        "engine": "",
        "expose_in_sqllab": false,
        "extra": "",
        "force_ctas_schema": "",
        "impersonate_user": false,
        "parameters": json!({}),
        "server_cert": "",
        "sqlalchemy_uri": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/database/ \
  --header 'content-type: application/json' \
  --data '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
echo '{
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}' |  \
  http POST {{baseUrl}}/database/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "allow_csv_upload": false,\n  "allow_ctas": false,\n  "allow_cvas": false,\n  "allow_dml": false,\n  "allow_multi_schema_metadata_fetch": false,\n  "allow_run_async": false,\n  "cache_timeout": 0,\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "expose_in_sqllab": false,\n  "extra": "",\n  "force_ctas_schema": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": "",\n  "sqlalchemy_uri": ""\n}' \
  --output-document \
  - {{baseUrl}}/database/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "allow_csv_upload": false,
  "allow_ctas": false,
  "allow_cvas": false,
  "allow_dml": false,
  "allow_multi_schema_metadata_fetch": false,
  "allow_run_async": false,
  "cache_timeout": 0,
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "expose_in_sqllab": false,
  "extra": "",
  "force_ctas_schema": "",
  "impersonate_user": false,
  "parameters": [],
  "server_cert": "",
  "sqlalchemy_uri": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Deletes a Database.
{{baseUrl}}/database/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/database/:pk")
require "http/client"

url = "{{baseUrl}}/database/:pk"

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}}/database/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk"

	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/database/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/database/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk"))
    .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}}/database/:pk")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/database/:pk")
  .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}}/database/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/database/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk';
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}}/database/:pk',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk',
  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}}/database/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/database/:pk');

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}}/database/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk';
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}}/database/:pk"]
                                                       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}}/database/:pk" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk",
  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}}/database/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/database/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk")

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/database/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/database/:pk
http DELETE {{baseUrl}}/database/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/database/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk")! 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()
GET Download database(s) and associated dataset(s) as a zip file
{{baseUrl}}/database/export/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/export/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/export/")
require "http/client"

url = "{{baseUrl}}/database/export/"

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}}/database/export/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/export/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/export/"

	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/database/export/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/export/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/export/"))
    .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}}/database/export/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/export/")
  .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}}/database/export/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/database/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/export/';
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}}/database/export/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/export/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/export/',
  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}}/database/export/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/export/');

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}}/database/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/export/';
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}}/database/export/"]
                                                       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}}/database/export/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/export/",
  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}}/database/export/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/export/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/export/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/export/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/export/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/export/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/export/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/export/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/export/")

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/database/export/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/export/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/export/
http GET {{baseUrl}}/database/export/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/export/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/export/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a list of models
{{baseUrl}}/database/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/")
require "http/client"

url = "{{baseUrl}}/database/"

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}}/database/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/"

	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/database/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/"))
    .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}}/database/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/")
  .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}}/database/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/database/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/';
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}}/database/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/',
  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}}/database/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/');

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}}/database/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/';
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}}/database/"]
                                                       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}}/database/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/",
  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}}/database/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/")

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/database/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/
http GET {{baseUrl}}/database/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get all schemas from a database
{{baseUrl}}/database/:pk/schemas/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk/schemas/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/:pk/schemas/")
require "http/client"

url = "{{baseUrl}}/database/:pk/schemas/"

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}}/database/:pk/schemas/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk/schemas/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk/schemas/"

	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/database/:pk/schemas/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/:pk/schemas/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk/schemas/"))
    .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}}/database/:pk/schemas/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/:pk/schemas/")
  .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}}/database/:pk/schemas/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/database/:pk/schemas/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk/schemas/';
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}}/database/:pk/schemas/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk/schemas/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk/schemas/',
  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}}/database/:pk/schemas/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/:pk/schemas/');

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}}/database/:pk/schemas/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk/schemas/';
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}}/database/:pk/schemas/"]
                                                       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}}/database/:pk/schemas/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk/schemas/",
  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}}/database/:pk/schemas/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk/schemas/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk/schemas/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk/schemas/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk/schemas/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/:pk/schemas/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk/schemas/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk/schemas/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk/schemas/")

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/database/:pk/schemas/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk/schemas/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/:pk/schemas/
http GET {{baseUrl}}/database/:pk/schemas/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/:pk/schemas/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk/schemas/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get an item model
{{baseUrl}}/database/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/:pk")
require "http/client"

url = "{{baseUrl}}/database/:pk"

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}}/database/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk"

	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/database/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk"))
    .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}}/database/:pk")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/:pk")
  .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}}/database/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/database/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk';
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}}/database/:pk',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk',
  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}}/database/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/:pk');

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}}/database/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk';
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}}/database/:pk"]
                                                       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}}/database/:pk" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk",
  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}}/database/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk")

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/database/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/:pk
http GET {{baseUrl}}/database/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
GET Get charts and dashboards count associated to a database
{{baseUrl}}/database/:pk/related_objects/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk/related_objects/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/:pk/related_objects/")
require "http/client"

url = "{{baseUrl}}/database/:pk/related_objects/"

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}}/database/:pk/related_objects/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk/related_objects/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk/related_objects/"

	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/database/:pk/related_objects/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/:pk/related_objects/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk/related_objects/"))
    .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}}/database/:pk/related_objects/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/:pk/related_objects/")
  .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}}/database/:pk/related_objects/');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/database/:pk/related_objects/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk/related_objects/';
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}}/database/:pk/related_objects/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk/related_objects/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk/related_objects/',
  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}}/database/:pk/related_objects/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/:pk/related_objects/');

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}}/database/:pk/related_objects/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk/related_objects/';
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}}/database/:pk/related_objects/"]
                                                       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}}/database/:pk/related_objects/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk/related_objects/",
  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}}/database/:pk/related_objects/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk/related_objects/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk/related_objects/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk/related_objects/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk/related_objects/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/:pk/related_objects/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk/related_objects/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk/related_objects/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk/related_objects/")

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/database/:pk/related_objects/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk/related_objects/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/:pk/related_objects/
http GET {{baseUrl}}/database/:pk/related_objects/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/:pk/related_objects/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk/related_objects/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get database select star for table (GET)
{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/
QUERY PARAMS
pk
table_name
schema_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/")
require "http/client"

url = "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/"

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}}/database/:pk/select_star/:table_name/:schema_name/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/"

	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/database/:pk/select_star/:table_name/:schema_name/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/"))
    .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}}/database/:pk/select_star/:table_name/:schema_name/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/")
  .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}}/database/:pk/select_star/:table_name/:schema_name/');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/';
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}}/database/:pk/select_star/:table_name/:schema_name/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk/select_star/:table_name/:schema_name/',
  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}}/database/:pk/select_star/:table_name/:schema_name/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/');

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}}/database/:pk/select_star/:table_name/:schema_name/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/';
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}}/database/:pk/select_star/:table_name/:schema_name/"]
                                                       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}}/database/:pk/select_star/:table_name/:schema_name/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/",
  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}}/database/:pk/select_star/:table_name/:schema_name/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/:pk/select_star/:table_name/:schema_name/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/")

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/database/:pk/select_star/:table_name/:schema_name/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/
http GET {{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk/select_star/:table_name/:schema_name/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get database select star for table
{{baseUrl}}/database/:pk/select_star/:table_name/
QUERY PARAMS
schema_name
pk
table_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/:pk/select_star/:table_name/" {:query-params {:schema_name ""}})
require "http/client"

url = "{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name="

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}}/database/:pk/select_star/:table_name/?schema_name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name="

	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/database/:pk/select_star/:table_name/?schema_name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name="))
    .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}}/database/:pk/select_star/:table_name/?schema_name=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=")
  .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}}/database/:pk/select_star/:table_name/?schema_name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/database/:pk/select_star/:table_name/',
  params: {schema_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=';
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}}/database/:pk/select_star/:table_name/?schema_name=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk/select_star/:table_name/?schema_name=',
  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}}/database/:pk/select_star/:table_name/',
  qs: {schema_name: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/:pk/select_star/:table_name/');

req.query({
  schema_name: ''
});

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}}/database/:pk/select_star/:table_name/',
  params: {schema_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=';
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}}/database/:pk/select_star/:table_name/?schema_name="]
                                                       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}}/database/:pk/select_star/:table_name/?schema_name=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=",
  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}}/database/:pk/select_star/:table_name/?schema_name=');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk/select_star/:table_name/');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'schema_name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk/select_star/:table_name/');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'schema_name' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/:pk/select_star/:table_name/?schema_name=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk/select_star/:table_name/"

querystring = {"schema_name":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk/select_star/:table_name/"

queryString <- list(schema_name = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=")

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/database/:pk/select_star/:table_name/') do |req|
  req.params['schema_name'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk/select_star/:table_name/";

    let querystring = [
        ("schema_name", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name='
http GET '{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk/select_star/:table_name/?schema_name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get database table metadata
{{baseUrl}}/database/:pk/table/:table_name/:schema_name/
QUERY PARAMS
pk
table_name
schema_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/")
require "http/client"

url = "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/"

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}}/database/:pk/table/:table_name/:schema_name/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk/table/:table_name/:schema_name/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/"

	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/database/:pk/table/:table_name/:schema_name/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk/table/:table_name/:schema_name/"))
    .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}}/database/:pk/table/:table_name/:schema_name/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/:pk/table/:table_name/:schema_name/")
  .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}}/database/:pk/table/:table_name/:schema_name/');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/database/:pk/table/:table_name/:schema_name/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk/table/:table_name/:schema_name/';
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}}/database/:pk/table/:table_name/:schema_name/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk/table/:table_name/:schema_name/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk/table/:table_name/:schema_name/',
  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}}/database/:pk/table/:table_name/:schema_name/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/:pk/table/:table_name/:schema_name/');

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}}/database/:pk/table/:table_name/:schema_name/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk/table/:table_name/:schema_name/';
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}}/database/:pk/table/:table_name/:schema_name/"]
                                                       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}}/database/:pk/table/:table_name/:schema_name/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/",
  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}}/database/:pk/table/:table_name/:schema_name/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk/table/:table_name/:schema_name/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk/table/:table_name/:schema_name/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk/table/:table_name/:schema_name/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk/table/:table_name/:schema_name/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/:pk/table/:table_name/:schema_name/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk/table/:table_name/:schema_name/")

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/database/:pk/table/:table_name/:schema_name/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/:pk/table/:table_name/:schema_name/
http GET {{baseUrl}}/database/:pk/table/:table_name/:schema_name/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/:pk/table/:table_name/:schema_name/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk/table/:table_name/:schema_name/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get function names supported by a database
{{baseUrl}}/database/:pk/function_names/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/:pk/function_names/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/:pk/function_names/")
require "http/client"

url = "{{baseUrl}}/database/:pk/function_names/"

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}}/database/:pk/function_names/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/:pk/function_names/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/:pk/function_names/"

	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/database/:pk/function_names/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/:pk/function_names/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/:pk/function_names/"))
    .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}}/database/:pk/function_names/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/:pk/function_names/")
  .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}}/database/:pk/function_names/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/database/:pk/function_names/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/:pk/function_names/';
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}}/database/:pk/function_names/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/:pk/function_names/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/:pk/function_names/',
  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}}/database/:pk/function_names/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/:pk/function_names/');

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}}/database/:pk/function_names/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/:pk/function_names/';
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}}/database/:pk/function_names/"]
                                                       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}}/database/:pk/function_names/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/:pk/function_names/",
  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}}/database/:pk/function_names/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/:pk/function_names/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/:pk/function_names/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/:pk/function_names/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/:pk/function_names/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/:pk/function_names/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/:pk/function_names/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/:pk/function_names/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/:pk/function_names/")

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/database/:pk/function_names/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/:pk/function_names/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/:pk/function_names/
http GET {{baseUrl}}/database/:pk/function_names/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/:pk/function_names/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/:pk/function_names/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get metadata information about this API resource (1)
{{baseUrl}}/database/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/_info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/_info")
require "http/client"

url = "{{baseUrl}}/database/_info"

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}}/database/_info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/_info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/_info"

	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/database/_info HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/_info")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/_info"))
    .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}}/database/_info")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/_info")
  .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}}/database/_info');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/database/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/_info';
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}}/database/_info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/_info")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/_info',
  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}}/database/_info'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/_info');

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}}/database/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/_info';
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}}/database/_info"]
                                                       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}}/database/_info" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/_info",
  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}}/database/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/database/_info');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/_info' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/_info")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/_info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/_info"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/_info")

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/database/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/_info";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/_info
http GET {{baseUrl}}/database/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/_info")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get names of databases currently available
{{baseUrl}}/database/available/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/available/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/database/available/")
require "http/client"

url = "{{baseUrl}}/database/available/"

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}}/database/available/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/available/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/available/"

	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/database/available/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/database/available/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/available/"))
    .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}}/database/available/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/database/available/")
  .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}}/database/available/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/database/available/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/available/';
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}}/database/available/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/database/available/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/available/',
  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}}/database/available/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/database/available/');

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}}/database/available/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/available/';
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}}/database/available/"]
                                                       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}}/database/available/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/available/",
  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}}/database/available/');

echo $response->getBody();
setUrl('{{baseUrl}}/database/available/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/database/available/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/available/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/available/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/database/available/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/available/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/available/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/available/")

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/database/available/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/available/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/database/available/
http GET {{baseUrl}}/database/available/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/database/available/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/available/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Tests a database connection
{{baseUrl}}/database/test_connection
BODY json
{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/test_connection");

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  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/database/test_connection" {:content-type :json
                                                                     :form-params {:configuration_method ""
                                                                                   :database_name ""
                                                                                   :encrypted_extra ""
                                                                                   :engine ""
                                                                                   :extra ""
                                                                                   :impersonate_user false
                                                                                   :parameters {}
                                                                                   :server_cert ""
                                                                                   :sqlalchemy_uri ""}})
require "http/client"

url = "{{baseUrl}}/database/test_connection"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/test_connection"),
    Content = new StringContent("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/test_connection");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/test_connection"

	payload := strings.NewReader("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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/database/test_connection HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 205

{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/database/test_connection")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/test_connection"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/database/test_connection")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/database/test_connection")
  .header("content-type", "application/json")
  .body("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  extra: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/database/test_connection');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/test_connection',
  headers: {'content-type': 'application/json'},
  data: {
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    extra: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/test_connection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","extra":"","impersonate_user":false,"parameters":{},"server_cert":"","sqlalchemy_uri":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/database/test_connection',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "extra": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": "",\n  "sqlalchemy_uri": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/database/test_connection")
  .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/database/test_connection',
  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({
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  extra: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/test_connection',
  headers: {'content-type': 'application/json'},
  body: {
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    extra: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  },
  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}}/database/test_connection');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  extra: '',
  impersonate_user: false,
  parameters: {},
  server_cert: '',
  sqlalchemy_uri: ''
});

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}}/database/test_connection',
  headers: {'content-type': 'application/json'},
  data: {
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    extra: '',
    impersonate_user: false,
    parameters: {},
    server_cert: '',
    sqlalchemy_uri: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/test_connection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","extra":"","impersonate_user":false,"parameters":{},"server_cert":"","sqlalchemy_uri":""}'
};

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 = @{ @"configuration_method": @"",
                              @"database_name": @"",
                              @"encrypted_extra": @"",
                              @"engine": @"",
                              @"extra": @"",
                              @"impersonate_user": @NO,
                              @"parameters": @{  },
                              @"server_cert": @"",
                              @"sqlalchemy_uri": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/database/test_connection"]
                                                       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}}/database/test_connection" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/test_connection",
  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([
    'configuration_method' => '',
    'database_name' => '',
    'encrypted_extra' => '',
    'engine' => '',
    'extra' => '',
    'impersonate_user' => null,
    'parameters' => [
        
    ],
    'server_cert' => '',
    'sqlalchemy_uri' => ''
  ]),
  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}}/database/test_connection', [
  'body' => '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/database/test_connection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'extra' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => '',
  'sqlalchemy_uri' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'extra' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => '',
  'sqlalchemy_uri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/database/test_connection');
$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}}/database/test_connection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/test_connection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/database/test_connection", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/test_connection"

payload = {
    "configuration_method": "",
    "database_name": "",
    "encrypted_extra": "",
    "engine": "",
    "extra": "",
    "impersonate_user": False,
    "parameters": {},
    "server_cert": "",
    "sqlalchemy_uri": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/test_connection"

payload <- "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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}}/database/test_connection")

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  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\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/database/test_connection') do |req|
  req.body = "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\",\n  \"sqlalchemy_uri\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/test_connection";

    let payload = json!({
        "configuration_method": "",
        "database_name": "",
        "encrypted_extra": "",
        "engine": "",
        "extra": "",
        "impersonate_user": false,
        "parameters": json!({}),
        "server_cert": "",
        "sqlalchemy_uri": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/database/test_connection \
  --header 'content-type: application/json' \
  --data '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}'
echo '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": "",
  "sqlalchemy_uri": ""
}' |  \
  http POST {{baseUrl}}/database/test_connection \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "extra": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": "",\n  "sqlalchemy_uri": ""\n}' \
  --output-document \
  - {{baseUrl}}/database/test_connection
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": [],
  "server_cert": "",
  "sqlalchemy_uri": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/test_connection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Validates parameters used to connect to a database
{{baseUrl}}/database/validate_parameters
BODY json
{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/validate_parameters");

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  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/database/validate_parameters" {:content-type :json
                                                                         :form-params {:configuration_method ""
                                                                                       :database_name ""
                                                                                       :encrypted_extra ""
                                                                                       :engine ""
                                                                                       :extra ""
                                                                                       :impersonate_user false
                                                                                       :parameters {}
                                                                                       :server_cert ""}})
require "http/client"

url = "{{baseUrl}}/database/validate_parameters"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\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}}/database/validate_parameters"),
    Content = new StringContent("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\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}}/database/validate_parameters");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/validate_parameters"

	payload := strings.NewReader("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\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/database/validate_parameters HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 181

{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/database/validate_parameters")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/validate_parameters"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\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  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/database/validate_parameters")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/database/validate_parameters")
  .header("content-type", "application/json")
  .body("{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  extra: '',
  impersonate_user: false,
  parameters: {},
  server_cert: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/database/validate_parameters');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/validate_parameters',
  headers: {'content-type': 'application/json'},
  data: {
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    extra: '',
    impersonate_user: false,
    parameters: {},
    server_cert: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/validate_parameters';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","extra":"","impersonate_user":false,"parameters":{},"server_cert":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/database/validate_parameters',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "extra": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/database/validate_parameters")
  .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/database/validate_parameters',
  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({
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  extra: '',
  impersonate_user: false,
  parameters: {},
  server_cert: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/validate_parameters',
  headers: {'content-type': 'application/json'},
  body: {
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    extra: '',
    impersonate_user: false,
    parameters: {},
    server_cert: ''
  },
  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}}/database/validate_parameters');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  configuration_method: '',
  database_name: '',
  encrypted_extra: '',
  engine: '',
  extra: '',
  impersonate_user: false,
  parameters: {},
  server_cert: ''
});

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}}/database/validate_parameters',
  headers: {'content-type': 'application/json'},
  data: {
    configuration_method: '',
    database_name: '',
    encrypted_extra: '',
    engine: '',
    extra: '',
    impersonate_user: false,
    parameters: {},
    server_cert: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/database/validate_parameters';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configuration_method":"","database_name":"","encrypted_extra":"","engine":"","extra":"","impersonate_user":false,"parameters":{},"server_cert":""}'
};

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 = @{ @"configuration_method": @"",
                              @"database_name": @"",
                              @"encrypted_extra": @"",
                              @"engine": @"",
                              @"extra": @"",
                              @"impersonate_user": @NO,
                              @"parameters": @{  },
                              @"server_cert": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/database/validate_parameters"]
                                                       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}}/database/validate_parameters" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/validate_parameters",
  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([
    'configuration_method' => '',
    'database_name' => '',
    'encrypted_extra' => '',
    'engine' => '',
    'extra' => '',
    'impersonate_user' => null,
    'parameters' => [
        
    ],
    'server_cert' => ''
  ]),
  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}}/database/validate_parameters', [
  'body' => '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/database/validate_parameters');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'extra' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'configuration_method' => '',
  'database_name' => '',
  'encrypted_extra' => '',
  'engine' => '',
  'extra' => '',
  'impersonate_user' => null,
  'parameters' => [
    
  ],
  'server_cert' => ''
]));
$request->setRequestUrl('{{baseUrl}}/database/validate_parameters');
$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}}/database/validate_parameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/validate_parameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/database/validate_parameters", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/validate_parameters"

payload = {
    "configuration_method": "",
    "database_name": "",
    "encrypted_extra": "",
    "engine": "",
    "extra": "",
    "impersonate_user": False,
    "parameters": {},
    "server_cert": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/validate_parameters"

payload <- "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\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}}/database/validate_parameters")

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  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\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/database/validate_parameters') do |req|
  req.body = "{\n  \"configuration_method\": \"\",\n  \"database_name\": \"\",\n  \"encrypted_extra\": \"\",\n  \"engine\": \"\",\n  \"extra\": \"\",\n  \"impersonate_user\": false,\n  \"parameters\": {},\n  \"server_cert\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/validate_parameters";

    let payload = json!({
        "configuration_method": "",
        "database_name": "",
        "encrypted_extra": "",
        "engine": "",
        "extra": "",
        "impersonate_user": false,
        "parameters": json!({}),
        "server_cert": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/database/validate_parameters \
  --header 'content-type: application/json' \
  --data '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": ""
}'
echo '{
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": {},
  "server_cert": ""
}' |  \
  http POST {{baseUrl}}/database/validate_parameters \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "configuration_method": "",\n  "database_name": "",\n  "encrypted_extra": "",\n  "engine": "",\n  "extra": "",\n  "impersonate_user": false,\n  "parameters": {},\n  "server_cert": ""\n}' \
  --output-document \
  - {{baseUrl}}/database/validate_parameters
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "configuration_method": "",
  "database_name": "",
  "encrypted_extra": "",
  "engine": "",
  "extra": "",
  "impersonate_user": false,
  "parameters": [],
  "server_cert": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/validate_parameters")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST post -database-import-
{{baseUrl}}/database/import/
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/database/import/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/database/import/" {:multipart [{:name "formData"
                                                                          :content ""} {:name "overwrite"
                                                                          :content ""} {:name "passwords"
                                                                          :content ""}]})
require "http/client"

url = "{{baseUrl}}/database/import/"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/database/import/"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "formData",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "overwrite",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "passwords",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/database/import/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/database/import/"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/database/import/ HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 287

-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/database/import/")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/database/import/"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/database/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/database/import/")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('formData', '');
data.append('overwrite', '');
data.append('passwords', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/database/import/');

xhr.send(data);
import axios from 'axios';

const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/database/import/';
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/database/import/',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/database/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/database/import/',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/database/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {formData: '', overwrite: '', passwords: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/database/import/');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/database/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('formData', '');
formData.append('overwrite', '');
formData.append('passwords', '');

const url = '{{baseUrl}}/database/import/';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"formData", @"value": @"" },
                         @{ @"name": @"overwrite", @"value": @"" },
                         @{ @"name": @"passwords", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/database/import/"]
                                                       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}}/database/import/" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/database/import/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/database/import/', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/database/import/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/database/import/');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/database/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/database/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/database/import/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/database/import/"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/database/import/"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/database/import/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/database/import/') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/database/import/";

    let form = reqwest::multipart::Form::new()
        .text("formData", "")
        .text("overwrite", "")
        .text("passwords", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/database/import/ \
  --header 'content-type: multipart/form-data' \
  --form formData= \
  --form overwrite= \
  --form passwords=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/database/import/ \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/database/import/
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "formData",
    "value": ""
  ],
  [
    "name": "overwrite",
    "value": ""
  ],
  [
    "name": "passwords",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/database/import/")! 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()
PUT Changes a Dataset
{{baseUrl}}/dataset/:pk
QUERY PARAMS
pk
BODY json
{
  "cache_timeout": 0,
  "columns": [
    {
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    }
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    {
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    }
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/:pk");

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  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/dataset/:pk" {:content-type :json
                                                       :form-params {:cache_timeout 0
                                                                     :columns [{:column_name ""
                                                                                :description ""
                                                                                :expression ""
                                                                                :filterable false
                                                                                :groupby false
                                                                                :id 0
                                                                                :is_active false
                                                                                :is_dttm false
                                                                                :python_date_format ""
                                                                                :type ""
                                                                                :uuid ""
                                                                                :verbose_name ""}]
                                                                     :database_id 0
                                                                     :default_endpoint ""
                                                                     :description ""
                                                                     :extra ""
                                                                     :fetch_values_predicate ""
                                                                     :filter_select_enabled false
                                                                     :is_sqllab_view false
                                                                     :main_dttm_col ""
                                                                     :metrics [{:d3format ""
                                                                                :description ""
                                                                                :expression ""
                                                                                :id 0
                                                                                :metric_name ""
                                                                                :metric_type ""
                                                                                :warning_text ""}]
                                                                     :offset 0
                                                                     :owners []
                                                                     :schema ""
                                                                     :sql ""
                                                                     :table_name ""
                                                                     :template_params ""}})
require "http/client"

url = "{{baseUrl}}/dataset/:pk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\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}}/dataset/:pk"),
    Content = new StringContent("{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\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}}/dataset/:pk");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/:pk"

	payload := strings.NewReader("{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\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/dataset/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 835

{
  "cache_timeout": 0,
  "columns": [
    {
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    }
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    {
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    }
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/dataset/:pk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/:pk"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\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  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dataset/:pk")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/dataset/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  cache_timeout: 0,
  columns: [
    {
      column_name: '',
      description: '',
      expression: '',
      filterable: false,
      groupby: false,
      id: 0,
      is_active: false,
      is_dttm: false,
      python_date_format: '',
      type: '',
      uuid: '',
      verbose_name: ''
    }
  ],
  database_id: 0,
  default_endpoint: '',
  description: '',
  extra: '',
  fetch_values_predicate: '',
  filter_select_enabled: false,
  is_sqllab_view: false,
  main_dttm_col: '',
  metrics: [
    {
      d3format: '',
      description: '',
      expression: '',
      id: 0,
      metric_name: '',
      metric_type: '',
      warning_text: ''
    }
  ],
  offset: 0,
  owners: [],
  schema: '',
  sql: '',
  table_name: '',
  template_params: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/dataset/:pk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/dataset/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    cache_timeout: 0,
    columns: [
      {
        column_name: '',
        description: '',
        expression: '',
        filterable: false,
        groupby: false,
        id: 0,
        is_active: false,
        is_dttm: false,
        python_date_format: '',
        type: '',
        uuid: '',
        verbose_name: ''
      }
    ],
    database_id: 0,
    default_endpoint: '',
    description: '',
    extra: '',
    fetch_values_predicate: '',
    filter_select_enabled: false,
    is_sqllab_view: false,
    main_dttm_col: '',
    metrics: [
      {
        d3format: '',
        description: '',
        expression: '',
        id: 0,
        metric_name: '',
        metric_type: '',
        warning_text: ''
      }
    ],
    offset: 0,
    owners: [],
    schema: '',
    sql: '',
    table_name: '',
    template_params: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cache_timeout":0,"columns":[{"column_name":"","description":"","expression":"","filterable":false,"groupby":false,"id":0,"is_active":false,"is_dttm":false,"python_date_format":"","type":"","uuid":"","verbose_name":""}],"database_id":0,"default_endpoint":"","description":"","extra":"","fetch_values_predicate":"","filter_select_enabled":false,"is_sqllab_view":false,"main_dttm_col":"","metrics":[{"d3format":"","description":"","expression":"","id":0,"metric_name":"","metric_type":"","warning_text":""}],"offset":0,"owners":[],"schema":"","sql":"","table_name":"","template_params":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dataset/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cache_timeout": 0,\n  "columns": [\n    {\n      "column_name": "",\n      "description": "",\n      "expression": "",\n      "filterable": false,\n      "groupby": false,\n      "id": 0,\n      "is_active": false,\n      "is_dttm": false,\n      "python_date_format": "",\n      "type": "",\n      "uuid": "",\n      "verbose_name": ""\n    }\n  ],\n  "database_id": 0,\n  "default_endpoint": "",\n  "description": "",\n  "extra": "",\n  "fetch_values_predicate": "",\n  "filter_select_enabled": false,\n  "is_sqllab_view": false,\n  "main_dttm_col": "",\n  "metrics": [\n    {\n      "d3format": "",\n      "description": "",\n      "expression": "",\n      "id": 0,\n      "metric_name": "",\n      "metric_type": "",\n      "warning_text": ""\n    }\n  ],\n  "offset": 0,\n  "owners": [],\n  "schema": "",\n  "sql": "",\n  "table_name": "",\n  "template_params": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dataset/:pk")
  .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/dataset/:pk',
  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({
  cache_timeout: 0,
  columns: [
    {
      column_name: '',
      description: '',
      expression: '',
      filterable: false,
      groupby: false,
      id: 0,
      is_active: false,
      is_dttm: false,
      python_date_format: '',
      type: '',
      uuid: '',
      verbose_name: ''
    }
  ],
  database_id: 0,
  default_endpoint: '',
  description: '',
  extra: '',
  fetch_values_predicate: '',
  filter_select_enabled: false,
  is_sqllab_view: false,
  main_dttm_col: '',
  metrics: [
    {
      d3format: '',
      description: '',
      expression: '',
      id: 0,
      metric_name: '',
      metric_type: '',
      warning_text: ''
    }
  ],
  offset: 0,
  owners: [],
  schema: '',
  sql: '',
  table_name: '',
  template_params: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/dataset/:pk',
  headers: {'content-type': 'application/json'},
  body: {
    cache_timeout: 0,
    columns: [
      {
        column_name: '',
        description: '',
        expression: '',
        filterable: false,
        groupby: false,
        id: 0,
        is_active: false,
        is_dttm: false,
        python_date_format: '',
        type: '',
        uuid: '',
        verbose_name: ''
      }
    ],
    database_id: 0,
    default_endpoint: '',
    description: '',
    extra: '',
    fetch_values_predicate: '',
    filter_select_enabled: false,
    is_sqllab_view: false,
    main_dttm_col: '',
    metrics: [
      {
        d3format: '',
        description: '',
        expression: '',
        id: 0,
        metric_name: '',
        metric_type: '',
        warning_text: ''
      }
    ],
    offset: 0,
    owners: [],
    schema: '',
    sql: '',
    table_name: '',
    template_params: ''
  },
  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}}/dataset/:pk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cache_timeout: 0,
  columns: [
    {
      column_name: '',
      description: '',
      expression: '',
      filterable: false,
      groupby: false,
      id: 0,
      is_active: false,
      is_dttm: false,
      python_date_format: '',
      type: '',
      uuid: '',
      verbose_name: ''
    }
  ],
  database_id: 0,
  default_endpoint: '',
  description: '',
  extra: '',
  fetch_values_predicate: '',
  filter_select_enabled: false,
  is_sqllab_view: false,
  main_dttm_col: '',
  metrics: [
    {
      d3format: '',
      description: '',
      expression: '',
      id: 0,
      metric_name: '',
      metric_type: '',
      warning_text: ''
    }
  ],
  offset: 0,
  owners: [],
  schema: '',
  sql: '',
  table_name: '',
  template_params: ''
});

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}}/dataset/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    cache_timeout: 0,
    columns: [
      {
        column_name: '',
        description: '',
        expression: '',
        filterable: false,
        groupby: false,
        id: 0,
        is_active: false,
        is_dttm: false,
        python_date_format: '',
        type: '',
        uuid: '',
        verbose_name: ''
      }
    ],
    database_id: 0,
    default_endpoint: '',
    description: '',
    extra: '',
    fetch_values_predicate: '',
    filter_select_enabled: false,
    is_sqllab_view: false,
    main_dttm_col: '',
    metrics: [
      {
        d3format: '',
        description: '',
        expression: '',
        id: 0,
        metric_name: '',
        metric_type: '',
        warning_text: ''
      }
    ],
    offset: 0,
    owners: [],
    schema: '',
    sql: '',
    table_name: '',
    template_params: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cache_timeout":0,"columns":[{"column_name":"","description":"","expression":"","filterable":false,"groupby":false,"id":0,"is_active":false,"is_dttm":false,"python_date_format":"","type":"","uuid":"","verbose_name":""}],"database_id":0,"default_endpoint":"","description":"","extra":"","fetch_values_predicate":"","filter_select_enabled":false,"is_sqllab_view":false,"main_dttm_col":"","metrics":[{"d3format":"","description":"","expression":"","id":0,"metric_name":"","metric_type":"","warning_text":""}],"offset":0,"owners":[],"schema":"","sql":"","table_name":"","template_params":""}'
};

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 = @{ @"cache_timeout": @0,
                              @"columns": @[ @{ @"column_name": @"", @"description": @"", @"expression": @"", @"filterable": @NO, @"groupby": @NO, @"id": @0, @"is_active": @NO, @"is_dttm": @NO, @"python_date_format": @"", @"type": @"", @"uuid": @"", @"verbose_name": @"" } ],
                              @"database_id": @0,
                              @"default_endpoint": @"",
                              @"description": @"",
                              @"extra": @"",
                              @"fetch_values_predicate": @"",
                              @"filter_select_enabled": @NO,
                              @"is_sqllab_view": @NO,
                              @"main_dttm_col": @"",
                              @"metrics": @[ @{ @"d3format": @"", @"description": @"", @"expression": @"", @"id": @0, @"metric_name": @"", @"metric_type": @"", @"warning_text": @"" } ],
                              @"offset": @0,
                              @"owners": @[  ],
                              @"schema": @"",
                              @"sql": @"",
                              @"table_name": @"",
                              @"template_params": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dataset/:pk"]
                                                       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}}/dataset/:pk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/:pk",
  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([
    'cache_timeout' => 0,
    'columns' => [
        [
                'column_name' => '',
                'description' => '',
                'expression' => '',
                'filterable' => null,
                'groupby' => null,
                'id' => 0,
                'is_active' => null,
                'is_dttm' => null,
                'python_date_format' => '',
                'type' => '',
                'uuid' => '',
                'verbose_name' => ''
        ]
    ],
    'database_id' => 0,
    'default_endpoint' => '',
    'description' => '',
    'extra' => '',
    'fetch_values_predicate' => '',
    'filter_select_enabled' => null,
    'is_sqllab_view' => null,
    'main_dttm_col' => '',
    'metrics' => [
        [
                'd3format' => '',
                'description' => '',
                'expression' => '',
                'id' => 0,
                'metric_name' => '',
                'metric_type' => '',
                'warning_text' => ''
        ]
    ],
    'offset' => 0,
    'owners' => [
        
    ],
    'schema' => '',
    'sql' => '',
    'table_name' => '',
    'template_params' => ''
  ]),
  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}}/dataset/:pk', [
  'body' => '{
  "cache_timeout": 0,
  "columns": [
    {
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    }
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    {
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    }
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/:pk');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cache_timeout' => 0,
  'columns' => [
    [
        'column_name' => '',
        'description' => '',
        'expression' => '',
        'filterable' => null,
        'groupby' => null,
        'id' => 0,
        'is_active' => null,
        'is_dttm' => null,
        'python_date_format' => '',
        'type' => '',
        'uuid' => '',
        'verbose_name' => ''
    ]
  ],
  'database_id' => 0,
  'default_endpoint' => '',
  'description' => '',
  'extra' => '',
  'fetch_values_predicate' => '',
  'filter_select_enabled' => null,
  'is_sqllab_view' => null,
  'main_dttm_col' => '',
  'metrics' => [
    [
        'd3format' => '',
        'description' => '',
        'expression' => '',
        'id' => 0,
        'metric_name' => '',
        'metric_type' => '',
        'warning_text' => ''
    ]
  ],
  'offset' => 0,
  'owners' => [
    
  ],
  'schema' => '',
  'sql' => '',
  'table_name' => '',
  'template_params' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'cache_timeout' => 0,
  'columns' => [
    [
        'column_name' => '',
        'description' => '',
        'expression' => '',
        'filterable' => null,
        'groupby' => null,
        'id' => 0,
        'is_active' => null,
        'is_dttm' => null,
        'python_date_format' => '',
        'type' => '',
        'uuid' => '',
        'verbose_name' => ''
    ]
  ],
  'database_id' => 0,
  'default_endpoint' => '',
  'description' => '',
  'extra' => '',
  'fetch_values_predicate' => '',
  'filter_select_enabled' => null,
  'is_sqllab_view' => null,
  'main_dttm_col' => '',
  'metrics' => [
    [
        'd3format' => '',
        'description' => '',
        'expression' => '',
        'id' => 0,
        'metric_name' => '',
        'metric_type' => '',
        'warning_text' => ''
    ]
  ],
  'offset' => 0,
  'owners' => [
    
  ],
  'schema' => '',
  'sql' => '',
  'table_name' => '',
  'template_params' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dataset/:pk');
$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}}/dataset/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cache_timeout": 0,
  "columns": [
    {
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    }
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    {
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    }
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cache_timeout": 0,
  "columns": [
    {
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    }
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    {
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    }
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/dataset/:pk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/:pk"

payload = {
    "cache_timeout": 0,
    "columns": [
        {
            "column_name": "",
            "description": "",
            "expression": "",
            "filterable": False,
            "groupby": False,
            "id": 0,
            "is_active": False,
            "is_dttm": False,
            "python_date_format": "",
            "type": "",
            "uuid": "",
            "verbose_name": ""
        }
    ],
    "database_id": 0,
    "default_endpoint": "",
    "description": "",
    "extra": "",
    "fetch_values_predicate": "",
    "filter_select_enabled": False,
    "is_sqllab_view": False,
    "main_dttm_col": "",
    "metrics": [
        {
            "d3format": "",
            "description": "",
            "expression": "",
            "id": 0,
            "metric_name": "",
            "metric_type": "",
            "warning_text": ""
        }
    ],
    "offset": 0,
    "owners": [],
    "schema": "",
    "sql": "",
    "table_name": "",
    "template_params": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/:pk"

payload <- "{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\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}}/dataset/:pk")

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  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\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/dataset/:pk') do |req|
  req.body = "{\n  \"cache_timeout\": 0,\n  \"columns\": [\n    {\n      \"column_name\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"filterable\": false,\n      \"groupby\": false,\n      \"id\": 0,\n      \"is_active\": false,\n      \"is_dttm\": false,\n      \"python_date_format\": \"\",\n      \"type\": \"\",\n      \"uuid\": \"\",\n      \"verbose_name\": \"\"\n    }\n  ],\n  \"database_id\": 0,\n  \"default_endpoint\": \"\",\n  \"description\": \"\",\n  \"extra\": \"\",\n  \"fetch_values_predicate\": \"\",\n  \"filter_select_enabled\": false,\n  \"is_sqllab_view\": false,\n  \"main_dttm_col\": \"\",\n  \"metrics\": [\n    {\n      \"d3format\": \"\",\n      \"description\": \"\",\n      \"expression\": \"\",\n      \"id\": 0,\n      \"metric_name\": \"\",\n      \"metric_type\": \"\",\n      \"warning_text\": \"\"\n    }\n  ],\n  \"offset\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"sql\": \"\",\n  \"table_name\": \"\",\n  \"template_params\": \"\"\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}}/dataset/:pk";

    let payload = json!({
        "cache_timeout": 0,
        "columns": (
            json!({
                "column_name": "",
                "description": "",
                "expression": "",
                "filterable": false,
                "groupby": false,
                "id": 0,
                "is_active": false,
                "is_dttm": false,
                "python_date_format": "",
                "type": "",
                "uuid": "",
                "verbose_name": ""
            })
        ),
        "database_id": 0,
        "default_endpoint": "",
        "description": "",
        "extra": "",
        "fetch_values_predicate": "",
        "filter_select_enabled": false,
        "is_sqllab_view": false,
        "main_dttm_col": "",
        "metrics": (
            json!({
                "d3format": "",
                "description": "",
                "expression": "",
                "id": 0,
                "metric_name": "",
                "metric_type": "",
                "warning_text": ""
            })
        ),
        "offset": 0,
        "owners": (),
        "schema": "",
        "sql": "",
        "table_name": "",
        "template_params": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/dataset/:pk \
  --header 'content-type: application/json' \
  --data '{
  "cache_timeout": 0,
  "columns": [
    {
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    }
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    {
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    }
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
}'
echo '{
  "cache_timeout": 0,
  "columns": [
    {
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    }
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    {
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    }
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
}' |  \
  http PUT {{baseUrl}}/dataset/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "cache_timeout": 0,\n  "columns": [\n    {\n      "column_name": "",\n      "description": "",\n      "expression": "",\n      "filterable": false,\n      "groupby": false,\n      "id": 0,\n      "is_active": false,\n      "is_dttm": false,\n      "python_date_format": "",\n      "type": "",\n      "uuid": "",\n      "verbose_name": ""\n    }\n  ],\n  "database_id": 0,\n  "default_endpoint": "",\n  "description": "",\n  "extra": "",\n  "fetch_values_predicate": "",\n  "filter_select_enabled": false,\n  "is_sqllab_view": false,\n  "main_dttm_col": "",\n  "metrics": [\n    {\n      "d3format": "",\n      "description": "",\n      "expression": "",\n      "id": 0,\n      "metric_name": "",\n      "metric_type": "",\n      "warning_text": ""\n    }\n  ],\n  "offset": 0,\n  "owners": [],\n  "schema": "",\n  "sql": "",\n  "table_name": "",\n  "template_params": ""\n}' \
  --output-document \
  - {{baseUrl}}/dataset/:pk
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cache_timeout": 0,
  "columns": [
    [
      "column_name": "",
      "description": "",
      "expression": "",
      "filterable": false,
      "groupby": false,
      "id": 0,
      "is_active": false,
      "is_dttm": false,
      "python_date_format": "",
      "type": "",
      "uuid": "",
      "verbose_name": ""
    ]
  ],
  "database_id": 0,
  "default_endpoint": "",
  "description": "",
  "extra": "",
  "fetch_values_predicate": "",
  "filter_select_enabled": false,
  "is_sqllab_view": false,
  "main_dttm_col": "",
  "metrics": [
    [
      "d3format": "",
      "description": "",
      "expression": "",
      "id": 0,
      "metric_name": "",
      "metric_type": "",
      "warning_text": ""
    ]
  ],
  "offset": 0,
  "owners": [],
  "schema": "",
  "sql": "",
  "table_name": "",
  "template_params": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/:pk")! 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()
POST Create a new Dataset
{{baseUrl}}/dataset/
BODY json
{
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/");

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  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/dataset/" {:content-type :json
                                                     :form-params {:database 0
                                                                   :owners []
                                                                   :schema ""
                                                                   :table_name ""}})
require "http/client"

url = "{{baseUrl}}/dataset/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\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}}/dataset/"),
    Content = new StringContent("{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\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}}/dataset/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/"

	payload := strings.NewReader("{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\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/dataset/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dataset/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\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  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dataset/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/dataset/")
  .header("content-type", "application/json")
  .body("{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  database: 0,
  owners: [],
  schema: '',
  table_name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/dataset/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dataset/',
  headers: {'content-type': 'application/json'},
  data: {database: 0, owners: [], schema: '', table_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"database":0,"owners":[],"schema":"","table_name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dataset/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "database": 0,\n  "owners": [],\n  "schema": "",\n  "table_name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dataset/")
  .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/dataset/',
  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({database: 0, owners: [], schema: '', table_name: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dataset/',
  headers: {'content-type': 'application/json'},
  body: {database: 0, owners: [], schema: '', table_name: ''},
  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}}/dataset/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  database: 0,
  owners: [],
  schema: '',
  table_name: ''
});

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}}/dataset/',
  headers: {'content-type': 'application/json'},
  data: {database: 0, owners: [], schema: '', table_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"database":0,"owners":[],"schema":"","table_name":""}'
};

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 = @{ @"database": @0,
                              @"owners": @[  ],
                              @"schema": @"",
                              @"table_name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dataset/"]
                                                       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}}/dataset/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/",
  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([
    'database' => 0,
    'owners' => [
        
    ],
    'schema' => '',
    'table_name' => ''
  ]),
  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}}/dataset/', [
  'body' => '{
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'database' => 0,
  'owners' => [
    
  ],
  'schema' => '',
  'table_name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'database' => 0,
  'owners' => [
    
  ],
  'schema' => '',
  'table_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dataset/');
$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}}/dataset/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/dataset/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/"

payload = {
    "database": 0,
    "owners": [],
    "schema": "",
    "table_name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/"

payload <- "{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\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}}/dataset/")

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  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\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/dataset/') do |req|
  req.body = "{\n  \"database\": 0,\n  \"owners\": [],\n  \"schema\": \"\",\n  \"table_name\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/";

    let payload = json!({
        "database": 0,
        "owners": (),
        "schema": "",
        "table_name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/dataset/ \
  --header 'content-type: application/json' \
  --data '{
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
}'
echo '{
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
}' |  \
  http POST {{baseUrl}}/dataset/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "database": 0,\n  "owners": [],\n  "schema": "",\n  "table_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/dataset/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "database": 0,
  "owners": [],
  "schema": "",
  "table_name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete a Dataset column
{{baseUrl}}/dataset/:pk/column/:column_id
QUERY PARAMS
pk
column_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/:pk/column/:column_id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dataset/:pk/column/:column_id")
require "http/client"

url = "{{baseUrl}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/:pk/column/:column_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/:pk/column/:column_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/dataset/:pk/column/:column_id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dataset/:pk/column/:column_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_id');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/dataset/:pk/column/:column_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/:pk/column/:column_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/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_id');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/:pk/column/:column_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/:pk/column/:column_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/:pk/column/:column_id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/:pk/column/:column_id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dataset/:pk/column/:column_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/:pk/column/:column_id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/:pk/column/:column_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/:pk/column/:column_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/dataset/:pk/column/:column_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}}/dataset/:pk/column/:column_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);
}

curl --request DELETE \
  --url {{baseUrl}}/dataset/:pk/column/:column_id
http DELETE {{baseUrl}}/dataset/:pk/column/:column_id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dataset/:pk/column/:column_id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/:pk/column/:column_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()
DELETE Delete a Dataset metric
{{baseUrl}}/dataset/:pk/metric/:metric_id
QUERY PARAMS
pk
metric_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/:pk/metric/:metric_id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dataset/:pk/metric/:metric_id")
require "http/client"

url = "{{baseUrl}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/:pk/metric/:metric_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/:pk/metric/:metric_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/dataset/:pk/metric/:metric_id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dataset/:pk/metric/:metric_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_id');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/dataset/:pk/metric/:metric_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/:pk/metric/:metric_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/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_id');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/:pk/metric/:metric_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/:pk/metric/:metric_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/:pk/metric/:metric_id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/:pk/metric/:metric_id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dataset/:pk/metric/:metric_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/:pk/metric/:metric_id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/:pk/metric/:metric_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/:pk/metric/:metric_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/dataset/:pk/metric/:metric_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}}/dataset/:pk/metric/:metric_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);
}

curl --request DELETE \
  --url {{baseUrl}}/dataset/:pk/metric/:metric_id
http DELETE {{baseUrl}}/dataset/:pk/metric/:metric_id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dataset/:pk/metric/:metric_id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/:pk/metric/:metric_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()
DELETE Deletes a Dataset
{{baseUrl}}/dataset/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dataset/:pk")
require "http/client"

url = "{{baseUrl}}/dataset/:pk"

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}}/dataset/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/:pk"

	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/dataset/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dataset/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/:pk"))
    .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}}/dataset/:pk")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/dataset/:pk")
  .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}}/dataset/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/dataset/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/:pk';
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}}/dataset/:pk',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/:pk")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/:pk',
  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}}/dataset/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dataset/:pk');

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}}/dataset/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/:pk';
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}}/dataset/:pk"]
                                                       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}}/dataset/:pk" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/:pk",
  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}}/dataset/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/:pk');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/:pk' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dataset/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/:pk"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/:pk"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/:pk")

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/dataset/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/:pk";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/dataset/:pk
http DELETE {{baseUrl}}/dataset/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dataset/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/:pk")! 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()
DELETE Deletes multiple Datasets in a bulk operation.
{{baseUrl}}/dataset/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dataset/")
require "http/client"

url = "{{baseUrl}}/dataset/"

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}}/dataset/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/"

	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/dataset/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dataset/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/"))
    .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}}/dataset/")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/dataset/")
  .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}}/dataset/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/dataset/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/';
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}}/dataset/',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/',
  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}}/dataset/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dataset/');

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}}/dataset/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/';
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}}/dataset/"]
                                                       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}}/dataset/" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/",
  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}}/dataset/');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dataset/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/")

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/dataset/') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/dataset/
http DELETE {{baseUrl}}/dataset/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dataset/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/")! 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()
GET Exports multiple datasets and downloads them as YAML files
{{baseUrl}}/dataset/export/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/export/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dataset/export/")
require "http/client"

url = "{{baseUrl}}/dataset/export/"

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}}/dataset/export/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/export/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/export/"

	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/dataset/export/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dataset/export/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/export/"))
    .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}}/dataset/export/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dataset/export/")
  .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}}/dataset/export/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dataset/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/export/';
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}}/dataset/export/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/export/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/export/',
  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}}/dataset/export/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataset/export/');

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}}/dataset/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/export/';
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}}/dataset/export/"]
                                                       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}}/dataset/export/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/export/",
  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}}/dataset/export/');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/export/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/export/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/export/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/export/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dataset/export/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/export/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/export/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/export/")

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/dataset/export/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/export/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dataset/export/
http GET {{baseUrl}}/dataset/export/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataset/export/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/export/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a list of models (GET)
{{baseUrl}}/dataset/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dataset/")
require "http/client"

url = "{{baseUrl}}/dataset/"

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}}/dataset/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/"

	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/dataset/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dataset/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/"))
    .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}}/dataset/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dataset/")
  .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}}/dataset/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dataset/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/';
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}}/dataset/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/',
  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}}/dataset/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataset/');

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}}/dataset/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/';
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}}/dataset/"]
                                                       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}}/dataset/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/",
  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}}/dataset/');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dataset/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/")

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/dataset/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dataset/
http GET {{baseUrl}}/dataset/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataset/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get an item model (GET)
{{baseUrl}}/dataset/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dataset/:pk")
require "http/client"

url = "{{baseUrl}}/dataset/:pk"

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}}/dataset/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/:pk");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/:pk"

	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/dataset/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dataset/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/:pk"))
    .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}}/dataset/:pk")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dataset/:pk")
  .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}}/dataset/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dataset/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/:pk';
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}}/dataset/:pk',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/:pk")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/:pk',
  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}}/dataset/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataset/:pk');

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}}/dataset/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/:pk';
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}}/dataset/:pk"]
                                                       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}}/dataset/:pk" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/:pk",
  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}}/dataset/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/:pk');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/:pk' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dataset/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/:pk"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/:pk"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/:pk")

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/dataset/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/:pk";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dataset/:pk
http GET {{baseUrl}}/dataset/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataset/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
GET Get charts and dashboards count associated to a dataset
{{baseUrl}}/dataset/:pk/related_objects
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/:pk/related_objects");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dataset/:pk/related_objects")
require "http/client"

url = "{{baseUrl}}/dataset/:pk/related_objects"

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}}/dataset/:pk/related_objects"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/:pk/related_objects");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/:pk/related_objects"

	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/dataset/:pk/related_objects HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dataset/:pk/related_objects")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/:pk/related_objects"))
    .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}}/dataset/:pk/related_objects")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dataset/:pk/related_objects")
  .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}}/dataset/:pk/related_objects');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dataset/:pk/related_objects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/:pk/related_objects';
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}}/dataset/:pk/related_objects',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/:pk/related_objects")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/:pk/related_objects',
  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}}/dataset/:pk/related_objects'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataset/:pk/related_objects');

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}}/dataset/:pk/related_objects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/:pk/related_objects';
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}}/dataset/:pk/related_objects"]
                                                       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}}/dataset/:pk/related_objects" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/:pk/related_objects",
  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}}/dataset/:pk/related_objects');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/:pk/related_objects');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/:pk/related_objects');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/:pk/related_objects' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/:pk/related_objects' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dataset/:pk/related_objects")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/:pk/related_objects"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/:pk/related_objects"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/:pk/related_objects")

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/dataset/:pk/related_objects') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/:pk/related_objects";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dataset/:pk/related_objects
http GET {{baseUrl}}/dataset/:pk/related_objects
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataset/:pk/related_objects
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/:pk/related_objects")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get metadata information about this API resource (2)
{{baseUrl}}/dataset/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/_info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dataset/_info")
require "http/client"

url = "{{baseUrl}}/dataset/_info"

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}}/dataset/_info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/_info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/_info"

	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/dataset/_info HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dataset/_info")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/_info"))
    .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}}/dataset/_info")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dataset/_info")
  .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}}/dataset/_info');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dataset/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/_info';
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}}/dataset/_info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/_info")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/_info',
  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}}/dataset/_info'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataset/_info');

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}}/dataset/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/_info';
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}}/dataset/_info"]
                                                       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}}/dataset/_info" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/_info",
  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}}/dataset/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/_info');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/_info' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dataset/_info")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/_info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/_info"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/_info")

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/dataset/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/_info";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dataset/_info
http GET {{baseUrl}}/dataset/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataset/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/_info")! 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()
PUT Refreshes and updates columns of a dataset
{{baseUrl}}/dataset/:pk/refresh
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/:pk/refresh");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/dataset/:pk/refresh")
require "http/client"

url = "{{baseUrl}}/dataset/:pk/refresh"

response = HTTP::Client.put url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/dataset/:pk/refresh"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/:pk/refresh");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/:pk/refresh"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/dataset/:pk/refresh HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/dataset/:pk/refresh")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/:pk/refresh"))
    .method("PUT", 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}}/dataset/:pk/refresh")
  .put(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/dataset/:pk/refresh")
  .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('PUT', '{{baseUrl}}/dataset/:pk/refresh');

xhr.send(data);
import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/dataset/:pk/refresh'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/:pk/refresh';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dataset/:pk/refresh',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/:pk/refresh")
  .put(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/:pk/refresh',
  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: 'PUT', url: '{{baseUrl}}/dataset/:pk/refresh'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/dataset/:pk/refresh');

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}}/dataset/:pk/refresh'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/:pk/refresh';
const options = {method: 'PUT'};

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}}/dataset/:pk/refresh"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/dataset/:pk/refresh" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/:pk/refresh",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/dataset/:pk/refresh');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/:pk/refresh');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/:pk/refresh');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/:pk/refresh' -Method PUT 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/:pk/refresh' -Method PUT 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/dataset/:pk/refresh")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/:pk/refresh"

response = requests.put(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/:pk/refresh"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/:pk/refresh")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/dataset/:pk/refresh') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/:pk/refresh";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/dataset/:pk/refresh
http PUT {{baseUrl}}/dataset/:pk/refresh
wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/dataset/:pk/refresh
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/:pk/refresh")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET get -dataset-distinct--column_name
{{baseUrl}}/dataset/distinct/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/distinct/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dataset/distinct/:column_name")
require "http/client"

url = "{{baseUrl}}/dataset/distinct/:column_name"

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}}/dataset/distinct/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/distinct/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/distinct/:column_name"

	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/dataset/distinct/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dataset/distinct/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/distinct/:column_name"))
    .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}}/dataset/distinct/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dataset/distinct/:column_name")
  .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}}/dataset/distinct/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/dataset/distinct/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/distinct/:column_name';
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}}/dataset/distinct/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/distinct/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/distinct/:column_name',
  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}}/dataset/distinct/:column_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataset/distinct/:column_name');

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}}/dataset/distinct/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/distinct/:column_name';
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}}/dataset/distinct/:column_name"]
                                                       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}}/dataset/distinct/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/distinct/:column_name",
  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}}/dataset/distinct/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/distinct/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/distinct/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/distinct/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/distinct/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dataset/distinct/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/distinct/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/distinct/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/distinct/:column_name")

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/dataset/distinct/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/distinct/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dataset/distinct/:column_name
http GET {{baseUrl}}/dataset/distinct/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataset/distinct/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/distinct/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET get -dataset-related--column_name
{{baseUrl}}/dataset/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/related/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dataset/related/:column_name")
require "http/client"

url = "{{baseUrl}}/dataset/related/:column_name"

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}}/dataset/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/related/:column_name"

	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/dataset/related/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dataset/related/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/related/:column_name"))
    .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}}/dataset/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/dataset/related/:column_name")
  .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}}/dataset/related/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dataset/related/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/related/:column_name';
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}}/dataset/related/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dataset/related/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/related/:column_name',
  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}}/dataset/related/:column_name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataset/related/:column_name');

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}}/dataset/related/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/dataset/related/:column_name';
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}}/dataset/related/:column_name"]
                                                       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}}/dataset/related/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/related/:column_name",
  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}}/dataset/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/related/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/dataset/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/related/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dataset/related/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/related/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/related/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/related/:column_name")

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/dataset/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/related/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/dataset/related/:column_name
http GET {{baseUrl}}/dataset/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataset/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/related/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST post -dataset-import-
{{baseUrl}}/dataset/import/
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataset/import/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/dataset/import/" {:multipart [{:name "formData"
                                                                         :content ""} {:name "overwrite"
                                                                         :content ""} {:name "passwords"
                                                                         :content ""}]})
require "http/client"

url = "{{baseUrl}}/dataset/import/"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/dataset/import/"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "formData",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "overwrite",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "passwords",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/dataset/import/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dataset/import/"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/dataset/import/ HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 287

-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dataset/import/")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataset/import/"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dataset/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/dataset/import/")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('formData', '');
data.append('overwrite', '');
data.append('passwords', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/dataset/import/');

xhr.send(data);
import axios from 'axios';

const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dataset/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/dataset/import/';
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dataset/import/',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/dataset/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dataset/import/',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dataset/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {formData: '', overwrite: '', passwords: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/dataset/import/');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/dataset/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('formData', '');
formData.append('overwrite', '');
formData.append('passwords', '');

const url = '{{baseUrl}}/dataset/import/';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"formData", @"value": @"" },
                         @{ @"name": @"overwrite", @"value": @"" },
                         @{ @"name": @"passwords", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dataset/import/"]
                                                       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}}/dataset/import/" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/dataset/import/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/dataset/import/', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/dataset/import/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/dataset/import/');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataset/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataset/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/dataset/import/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/dataset/import/"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/dataset/import/"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataset/import/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/dataset/import/') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dataset/import/";

    let form = reqwest::multipart::Form::new()
        .text("formData", "")
        .text("overwrite", "")
        .text("passwords", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/dataset/import/ \
  --header 'content-type: multipart/form-data' \
  --form formData= \
  --form overwrite= \
  --form passwords=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/dataset/import/ \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/dataset/import/
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "formData",
    "value": ""
  ],
  [
    "name": "overwrite",
    "value": ""
  ],
  [
    "name": "passwords",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dataset/import/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a list of models (1)
{{baseUrl}}/log/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/log/")
require "http/client"

url = "{{baseUrl}}/log/"

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}}/log/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/log/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/log/"

	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/log/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/log/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log/"))
    .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}}/log/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/log/")
  .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}}/log/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/log/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/log/';
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}}/log/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/log/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/log/',
  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}}/log/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/log/');

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}}/log/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/log/';
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}}/log/"]
                                                       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}}/log/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/log/",
  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}}/log/');

echo $response->getBody();
setUrl('{{baseUrl}}/log/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/log/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/log/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/log/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/log/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/log/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/log/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/log/")

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/log/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/log/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/log/
http GET {{baseUrl}}/log/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/log/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/log/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get an item model (1)
{{baseUrl}}/log/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/log/:pk")
require "http/client"

url = "{{baseUrl}}/log/:pk"

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}}/log/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/log/:pk");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/log/:pk"

	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/log/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/log/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log/:pk"))
    .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}}/log/:pk")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/log/:pk")
  .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}}/log/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/log/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/log/:pk';
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}}/log/:pk',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/log/:pk")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/log/:pk',
  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}}/log/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/log/:pk');

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}}/log/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/log/:pk';
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}}/log/:pk"]
                                                       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}}/log/:pk" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/log/:pk",
  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}}/log/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/log/:pk');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/log/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/log/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/log/:pk' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/log/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/log/:pk"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/log/:pk"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/log/:pk")

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/log/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/log/:pk";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/log/:pk
http GET {{baseUrl}}/log/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/log/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/log/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
POST post -log-
{{baseUrl}}/log/
BODY json
{
  "id": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/log/");

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  \"id\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/log/" {:content-type :json
                                                 :form-params {:id 0}})
require "http/client"

url = "{{baseUrl}}/log/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": 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}}/log/"),
    Content = new StringContent("{\n  \"id\": 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}}/log/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/log/"

	payload := strings.NewReader("{\n  \"id\": 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/log/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 13

{
  "id": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/log/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/log/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": 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  \"id\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/log/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/log/")
  .header("content-type", "application/json")
  .body("{\n  \"id\": 0\n}")
  .asString();
const data = JSON.stringify({
  id: 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}}/log/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/log/',
  headers: {'content-type': 'application/json'},
  data: {id: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/log/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":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}}/log/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": 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  \"id\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/log/")
  .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/log/',
  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({id: 0}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/log/',
  headers: {'content-type': 'application/json'},
  body: {id: 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}}/log/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: 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}}/log/',
  headers: {'content-type': 'application/json'},
  data: {id: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/log/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":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 = @{ @"id": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/log/"]
                                                       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}}/log/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/log/",
  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([
    'id' => 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}}/log/', [
  'body' => '{
  "id": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/log/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'id' => 0
]));
$request->setRequestUrl('{{baseUrl}}/log/');
$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}}/log/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/log/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/log/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/log/"

payload = { "id": 0 }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/log/"

payload <- "{\n  \"id\": 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}}/log/")

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  \"id\": 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/log/') do |req|
  req.body = "{\n  \"id\": 0\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/log/";

    let payload = json!({"id": 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);
}

curl --request POST \
  --url {{baseUrl}}/log/ \
  --header 'content-type: application/json' \
  --data '{
  "id": 0
}'
echo '{
  "id": 0
}' |  \
  http POST {{baseUrl}}/log/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": 0\n}' \
  --output-document \
  - {{baseUrl}}/log/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["id": 0] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/log/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get the menu data structure. Returns a forest like structure with the menu the user has access to
{{baseUrl}}/menu/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/menu/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/menu/")
require "http/client"

url = "{{baseUrl}}/menu/"

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}}/menu/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/menu/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/menu/"

	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/menu/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/menu/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/menu/"))
    .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}}/menu/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/menu/")
  .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}}/menu/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/menu/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/menu/';
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}}/menu/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/menu/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/menu/',
  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}}/menu/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/menu/');

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}}/menu/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/menu/';
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}}/menu/"]
                                                       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}}/menu/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/menu/",
  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}}/menu/');

echo $response->getBody();
setUrl('{{baseUrl}}/menu/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/menu/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/menu/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/menu/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/menu/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/menu/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/menu/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/menu/")

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/menu/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/menu/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/menu/
http GET {{baseUrl}}/menu/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/menu/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/menu/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get the OpenAPI spec for a specific API version
{{baseUrl}}/openapi/:version/_openapi
QUERY PARAMS
version
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/openapi/:version/_openapi");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/openapi/:version/_openapi")
require "http/client"

url = "{{baseUrl}}/openapi/:version/_openapi"

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}}/openapi/:version/_openapi"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/openapi/:version/_openapi");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/openapi/:version/_openapi"

	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/openapi/:version/_openapi HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/openapi/:version/_openapi")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/openapi/:version/_openapi"))
    .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}}/openapi/:version/_openapi")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/openapi/:version/_openapi")
  .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}}/openapi/:version/_openapi');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/openapi/:version/_openapi'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/openapi/:version/_openapi';
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}}/openapi/:version/_openapi',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/openapi/:version/_openapi")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/openapi/:version/_openapi',
  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}}/openapi/:version/_openapi'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/openapi/:version/_openapi');

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}}/openapi/:version/_openapi'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/openapi/:version/_openapi';
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}}/openapi/:version/_openapi"]
                                                       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}}/openapi/:version/_openapi" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/openapi/:version/_openapi",
  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}}/openapi/:version/_openapi');

echo $response->getBody();
setUrl('{{baseUrl}}/openapi/:version/_openapi');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/openapi/:version/_openapi');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/openapi/:version/_openapi' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/openapi/:version/_openapi' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/openapi/:version/_openapi")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/openapi/:version/_openapi"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/openapi/:version/_openapi"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/openapi/:version/_openapi")

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/openapi/:version/_openapi') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/openapi/:version/_openapi";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/openapi/:version/_openapi
http GET {{baseUrl}}/openapi/:version/_openapi
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/openapi/:version/_openapi
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/openapi/:version/_openapi")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a saved query
{{baseUrl}}/saved_query/
BODY json
{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/");

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  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/saved_query/" {:content-type :json
                                                         :form-params {:db_id 0
                                                                       :description ""
                                                                       :label ""
                                                                       :schema ""
                                                                       :sql ""}})
require "http/client"

url = "{{baseUrl}}/saved_query/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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}}/saved_query/"),
    Content = new StringContent("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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}}/saved_query/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/"

	payload := strings.NewReader("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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/saved_query/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/saved_query/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/saved_query/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/saved_query/")
  .header("content-type", "application/json")
  .body("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  db_id: 0,
  description: '',
  label: '',
  schema: '',
  sql: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/saved_query/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/saved_query/',
  headers: {'content-type': 'application/json'},
  data: {db_id: 0, description: '', label: '', schema: '', sql: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"db_id":0,"description":"","label":"","schema":"","sql":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/saved_query/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "db_id": 0,\n  "description": "",\n  "label": "",\n  "schema": "",\n  "sql": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/")
  .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/saved_query/',
  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({db_id: 0, description: '', label: '', schema: '', sql: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/saved_query/',
  headers: {'content-type': 'application/json'},
  body: {db_id: 0, description: '', label: '', schema: '', sql: ''},
  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}}/saved_query/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  db_id: 0,
  description: '',
  label: '',
  schema: '',
  sql: ''
});

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}}/saved_query/',
  headers: {'content-type': 'application/json'},
  data: {db_id: 0, description: '', label: '', schema: '', sql: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"db_id":0,"description":"","label":"","schema":"","sql":""}'
};

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 = @{ @"db_id": @0,
                              @"description": @"",
                              @"label": @"",
                              @"schema": @"",
                              @"sql": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/saved_query/"]
                                                       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}}/saved_query/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/",
  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([
    'db_id' => 0,
    'description' => '',
    'label' => '',
    'schema' => '',
    'sql' => ''
  ]),
  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}}/saved_query/', [
  'body' => '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'db_id' => 0,
  'description' => '',
  'label' => '',
  'schema' => '',
  'sql' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'db_id' => 0,
  'description' => '',
  'label' => '',
  'schema' => '',
  'sql' => ''
]));
$request->setRequestUrl('{{baseUrl}}/saved_query/');
$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}}/saved_query/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/saved_query/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/"

payload = {
    "db_id": 0,
    "description": "",
    "label": "",
    "schema": "",
    "sql": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/"

payload <- "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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}}/saved_query/")

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  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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/saved_query/') do |req|
  req.body = "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/";

    let payload = json!({
        "db_id": 0,
        "description": "",
        "label": "",
        "schema": "",
        "sql": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/saved_query/ \
  --header 'content-type: application/json' \
  --data '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}'
echo '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}' |  \
  http POST {{baseUrl}}/saved_query/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "db_id": 0,\n  "description": "",\n  "label": "",\n  "schema": "",\n  "sql": ""\n}' \
  --output-document \
  - {{baseUrl}}/saved_query/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Delete saved query
{{baseUrl}}/saved_query/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/saved_query/:pk")
require "http/client"

url = "{{baseUrl}}/saved_query/:pk"

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}}/saved_query/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/:pk"

	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/saved_query/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/saved_query/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/:pk"))
    .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}}/saved_query/:pk")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/saved_query/:pk")
  .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}}/saved_query/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/saved_query/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/:pk';
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}}/saved_query/:pk',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/:pk")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/:pk',
  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}}/saved_query/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/saved_query/:pk');

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}}/saved_query/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/:pk';
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}}/saved_query/:pk"]
                                                       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}}/saved_query/:pk" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/:pk",
  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}}/saved_query/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/:pk');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/:pk' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/saved_query/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/:pk"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/:pk"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/:pk")

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/saved_query/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/:pk";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/saved_query/:pk
http DELETE {{baseUrl}}/saved_query/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/saved_query/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/:pk")! 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()
DELETE Deletes multiple saved queries in a bulk operation.
{{baseUrl}}/saved_query/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/saved_query/")
require "http/client"

url = "{{baseUrl}}/saved_query/"

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}}/saved_query/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/"

	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/saved_query/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/saved_query/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/"))
    .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}}/saved_query/")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/saved_query/")
  .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}}/saved_query/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/saved_query/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/';
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}}/saved_query/',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/',
  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}}/saved_query/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/saved_query/');

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}}/saved_query/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/';
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}}/saved_query/"]
                                                       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}}/saved_query/" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/",
  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}}/saved_query/');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/saved_query/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/")

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/saved_query/') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/saved_query/
http DELETE {{baseUrl}}/saved_query/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/saved_query/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/")! 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()
GET Exports multiple saved queries and downloads them as YAML files
{{baseUrl}}/saved_query/export/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/export/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/saved_query/export/")
require "http/client"

url = "{{baseUrl}}/saved_query/export/"

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}}/saved_query/export/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/export/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/export/"

	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/saved_query/export/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/saved_query/export/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/export/"))
    .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}}/saved_query/export/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/saved_query/export/")
  .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}}/saved_query/export/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/saved_query/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/export/';
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}}/saved_query/export/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/export/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/export/',
  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}}/saved_query/export/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/saved_query/export/');

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}}/saved_query/export/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/export/';
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}}/saved_query/export/"]
                                                       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}}/saved_query/export/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/export/",
  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}}/saved_query/export/');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/export/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/export/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/export/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/export/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/saved_query/export/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/export/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/export/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/export/")

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/saved_query/export/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/export/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/saved_query/export/
http GET {{baseUrl}}/saved_query/export/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/saved_query/export/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/export/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a list of queries, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/query/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/query/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/query/")
require "http/client"

url = "{{baseUrl}}/query/"

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}}/query/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/query/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/query/"

	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/query/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/query/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/query/"))
    .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}}/query/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/query/")
  .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}}/query/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/query/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/query/';
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}}/query/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/query/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/query/',
  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}}/query/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/query/');

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}}/query/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/query/';
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}}/query/"]
                                                       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}}/query/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/query/",
  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}}/query/');

echo $response->getBody();
setUrl('{{baseUrl}}/query/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/query/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/query/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/query/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/query/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/query/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/query/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/query/")

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/query/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/query/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/query/
http GET {{baseUrl}}/query/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/query/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/query/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get a list of saved queries, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/saved_query/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/saved_query/")
require "http/client"

url = "{{baseUrl}}/saved_query/"

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}}/saved_query/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/"

	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/saved_query/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/saved_query/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/"))
    .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}}/saved_query/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/saved_query/")
  .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}}/saved_query/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/saved_query/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/';
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}}/saved_query/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/',
  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}}/saved_query/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/saved_query/');

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}}/saved_query/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/';
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}}/saved_query/"]
                                                       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}}/saved_query/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/",
  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}}/saved_query/');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/saved_query/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/")

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/saved_query/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/saved_query/
http GET {{baseUrl}}/saved_query/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/saved_query/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get a saved query
{{baseUrl}}/saved_query/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/saved_query/:pk")
require "http/client"

url = "{{baseUrl}}/saved_query/:pk"

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}}/saved_query/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/:pk");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/:pk"

	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/saved_query/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/saved_query/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/:pk"))
    .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}}/saved_query/:pk")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/saved_query/:pk")
  .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}}/saved_query/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/saved_query/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/:pk';
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}}/saved_query/:pk',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/:pk")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/:pk',
  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}}/saved_query/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/saved_query/:pk');

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}}/saved_query/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/:pk';
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}}/saved_query/:pk"]
                                                       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}}/saved_query/:pk" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/:pk",
  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}}/saved_query/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/:pk');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/:pk' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/saved_query/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/:pk"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/:pk"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/:pk")

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/saved_query/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/:pk";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/saved_query/:pk
http GET {{baseUrl}}/saved_query/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/saved_query/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
GET Get metadata information about this API resource (3)
{{baseUrl}}/saved_query/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/_info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/saved_query/_info")
require "http/client"

url = "{{baseUrl}}/saved_query/_info"

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}}/saved_query/_info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/_info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/_info"

	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/saved_query/_info HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/saved_query/_info")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/_info"))
    .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}}/saved_query/_info")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/saved_query/_info")
  .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}}/saved_query/_info');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/saved_query/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/_info';
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}}/saved_query/_info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/_info")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/_info',
  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}}/saved_query/_info'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/saved_query/_info');

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}}/saved_query/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/_info';
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}}/saved_query/_info"]
                                                       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}}/saved_query/_info" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/_info",
  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}}/saved_query/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/_info');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/_info' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/saved_query/_info")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/_info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/_info"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/_info")

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/saved_query/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/_info";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/saved_query/_info
http GET {{baseUrl}}/saved_query/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/saved_query/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/_info")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get query detail information.
{{baseUrl}}/query/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/query/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/query/:pk")
require "http/client"

url = "{{baseUrl}}/query/:pk"

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}}/query/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/query/:pk");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/query/:pk"

	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/query/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/query/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/query/:pk"))
    .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}}/query/:pk")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/query/:pk")
  .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}}/query/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/query/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/query/:pk';
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}}/query/:pk',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/query/:pk")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/query/:pk',
  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}}/query/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/query/:pk');

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}}/query/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/query/:pk';
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}}/query/:pk"]
                                                       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}}/query/:pk" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/query/:pk",
  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}}/query/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/query/:pk');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/query/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/query/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/query/:pk' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/query/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/query/:pk"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/query/:pk"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/query/:pk")

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/query/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/query/:pk";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/query/:pk
http GET {{baseUrl}}/query/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/query/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/query/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
PUT Update a saved query
{{baseUrl}}/saved_query/:pk
QUERY PARAMS
pk
BODY json
{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/:pk");

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  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/saved_query/:pk" {:content-type :json
                                                           :form-params {:db_id 0
                                                                         :description ""
                                                                         :label ""
                                                                         :schema ""
                                                                         :sql ""}})
require "http/client"

url = "{{baseUrl}}/saved_query/:pk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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}}/saved_query/:pk"),
    Content = new StringContent("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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}}/saved_query/:pk");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/:pk"

	payload := strings.NewReader("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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/saved_query/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/saved_query/:pk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/:pk"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/saved_query/:pk")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/saved_query/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  db_id: 0,
  description: '',
  label: '',
  schema: '',
  sql: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/saved_query/:pk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/saved_query/:pk',
  headers: {'content-type': 'application/json'},
  data: {db_id: 0, description: '', label: '', schema: '', sql: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"db_id":0,"description":"","label":"","schema":"","sql":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/saved_query/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "db_id": 0,\n  "description": "",\n  "label": "",\n  "schema": "",\n  "sql": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/:pk")
  .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/saved_query/:pk',
  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({db_id: 0, description: '', label: '', schema: '', sql: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/saved_query/:pk',
  headers: {'content-type': 'application/json'},
  body: {db_id: 0, description: '', label: '', schema: '', sql: ''},
  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}}/saved_query/:pk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  db_id: 0,
  description: '',
  label: '',
  schema: '',
  sql: ''
});

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}}/saved_query/:pk',
  headers: {'content-type': 'application/json'},
  data: {db_id: 0, description: '', label: '', schema: '', sql: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"db_id":0,"description":"","label":"","schema":"","sql":""}'
};

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 = @{ @"db_id": @0,
                              @"description": @"",
                              @"label": @"",
                              @"schema": @"",
                              @"sql": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/saved_query/:pk"]
                                                       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}}/saved_query/:pk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/:pk",
  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([
    'db_id' => 0,
    'description' => '',
    'label' => '',
    'schema' => '',
    'sql' => ''
  ]),
  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}}/saved_query/:pk', [
  'body' => '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/:pk');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'db_id' => 0,
  'description' => '',
  'label' => '',
  'schema' => '',
  'sql' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'db_id' => 0,
  'description' => '',
  'label' => '',
  'schema' => '',
  'sql' => ''
]));
$request->setRequestUrl('{{baseUrl}}/saved_query/:pk');
$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}}/saved_query/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/saved_query/:pk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/:pk"

payload = {
    "db_id": 0,
    "description": "",
    "label": "",
    "schema": "",
    "sql": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/:pk"

payload <- "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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}}/saved_query/:pk")

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  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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/saved_query/:pk') do |req|
  req.body = "{\n  \"db_id\": 0,\n  \"description\": \"\",\n  \"label\": \"\",\n  \"schema\": \"\",\n  \"sql\": \"\"\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}}/saved_query/:pk";

    let payload = json!({
        "db_id": 0,
        "description": "",
        "label": "",
        "schema": "",
        "sql": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/saved_query/:pk \
  --header 'content-type: application/json' \
  --data '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}'
echo '{
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
}' |  \
  http PUT {{baseUrl}}/saved_query/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "db_id": 0,\n  "description": "",\n  "label": "",\n  "schema": "",\n  "sql": ""\n}' \
  --output-document \
  - {{baseUrl}}/saved_query/:pk
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "db_id": 0,
  "description": "",
  "label": "",
  "schema": "",
  "sql": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/:pk")! 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()
GET get -query-distinct--column_name
{{baseUrl}}/query/distinct/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/query/distinct/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/query/distinct/:column_name")
require "http/client"

url = "{{baseUrl}}/query/distinct/:column_name"

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}}/query/distinct/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/query/distinct/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/query/distinct/:column_name"

	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/query/distinct/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/query/distinct/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/query/distinct/:column_name"))
    .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}}/query/distinct/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/query/distinct/:column_name")
  .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}}/query/distinct/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/query/distinct/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/query/distinct/:column_name';
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}}/query/distinct/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/query/distinct/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/query/distinct/:column_name',
  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}}/query/distinct/:column_name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/query/distinct/:column_name');

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}}/query/distinct/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/query/distinct/:column_name';
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}}/query/distinct/:column_name"]
                                                       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}}/query/distinct/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/query/distinct/:column_name",
  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}}/query/distinct/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/query/distinct/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/query/distinct/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/query/distinct/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/query/distinct/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/query/distinct/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/query/distinct/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/query/distinct/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/query/distinct/:column_name")

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/query/distinct/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/query/distinct/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/query/distinct/:column_name
http GET {{baseUrl}}/query/distinct/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/query/distinct/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/query/distinct/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET get -query-related--column_name
{{baseUrl}}/query/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/query/related/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/query/related/:column_name")
require "http/client"

url = "{{baseUrl}}/query/related/:column_name"

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}}/query/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/query/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/query/related/:column_name"

	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/query/related/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/query/related/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/query/related/:column_name"))
    .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}}/query/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/query/related/:column_name")
  .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}}/query/related/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/query/related/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/query/related/:column_name';
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}}/query/related/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/query/related/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/query/related/:column_name',
  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}}/query/related/:column_name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/query/related/:column_name');

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}}/query/related/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/query/related/:column_name';
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}}/query/related/:column_name"]
                                                       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}}/query/related/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/query/related/:column_name",
  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}}/query/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/query/related/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/query/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/query/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/query/related/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/query/related/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/query/related/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/query/related/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/query/related/:column_name")

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/query/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/query/related/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/query/related/:column_name
http GET {{baseUrl}}/query/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/query/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/query/related/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET get -saved_query-distinct--column_name
{{baseUrl}}/saved_query/distinct/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/distinct/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/saved_query/distinct/:column_name")
require "http/client"

url = "{{baseUrl}}/saved_query/distinct/:column_name"

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}}/saved_query/distinct/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/distinct/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/distinct/:column_name"

	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/saved_query/distinct/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/saved_query/distinct/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/distinct/:column_name"))
    .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}}/saved_query/distinct/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/saved_query/distinct/:column_name")
  .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}}/saved_query/distinct/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/saved_query/distinct/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/distinct/:column_name';
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}}/saved_query/distinct/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/distinct/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/distinct/:column_name',
  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}}/saved_query/distinct/:column_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/saved_query/distinct/:column_name');

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}}/saved_query/distinct/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/distinct/:column_name';
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}}/saved_query/distinct/:column_name"]
                                                       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}}/saved_query/distinct/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/distinct/:column_name",
  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}}/saved_query/distinct/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/distinct/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/distinct/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/distinct/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/distinct/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/saved_query/distinct/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/distinct/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/distinct/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/distinct/:column_name")

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/saved_query/distinct/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/distinct/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/saved_query/distinct/:column_name
http GET {{baseUrl}}/saved_query/distinct/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/saved_query/distinct/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/distinct/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET get -saved_query-related--column_name
{{baseUrl}}/saved_query/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/related/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/saved_query/related/:column_name")
require "http/client"

url = "{{baseUrl}}/saved_query/related/:column_name"

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}}/saved_query/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/related/:column_name"

	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/saved_query/related/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/saved_query/related/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/related/:column_name"))
    .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}}/saved_query/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/saved_query/related/:column_name")
  .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}}/saved_query/related/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/saved_query/related/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/related/:column_name';
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}}/saved_query/related/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/related/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/related/:column_name',
  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}}/saved_query/related/:column_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/saved_query/related/:column_name');

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}}/saved_query/related/:column_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/saved_query/related/:column_name';
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}}/saved_query/related/:column_name"]
                                                       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}}/saved_query/related/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/related/:column_name",
  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}}/saved_query/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/related/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/saved_query/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/related/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/saved_query/related/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/related/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/related/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/related/:column_name")

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/saved_query/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/related/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/saved_query/related/:column_name
http GET {{baseUrl}}/saved_query/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/saved_query/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/related/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST post -saved_query-import-
{{baseUrl}}/saved_query/import/
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/saved_query/import/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/saved_query/import/" {:multipart [{:name "formData"
                                                                             :content ""} {:name "overwrite"
                                                                             :content ""} {:name "passwords"
                                                                             :content ""}]})
require "http/client"

url = "{{baseUrl}}/saved_query/import/"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/saved_query/import/"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "formData",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "overwrite",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "passwords",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/saved_query/import/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/saved_query/import/"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
POST /baseUrl/saved_query/import/ HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 287

-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/saved_query/import/")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/saved_query/import/"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/saved_query/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/saved_query/import/")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('formData', '');
data.append('overwrite', '');
data.append('passwords', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/saved_query/import/');

xhr.send(data);
import axios from 'axios';

const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/saved_query/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/saved_query/import/';
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('formData', '');
form.append('overwrite', '');
form.append('passwords', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/saved_query/import/',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/saved_query/import/")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/saved_query/import/',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/saved_query/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {formData: '', overwrite: '', passwords: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/saved_query/import/');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/saved_query/import/',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('formData', '');
formData.append('overwrite', '');
formData.append('passwords', '');

const url = '{{baseUrl}}/saved_query/import/';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"formData", @"value": @"" },
                         @{ @"name": @"overwrite", @"value": @"" },
                         @{ @"name": @"passwords", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/saved_query/import/"]
                                                       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}}/saved_query/import/" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/saved_query/import/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/saved_query/import/', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/saved_query/import/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/saved_query/import/');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/saved_query/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/saved_query/import/' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/saved_query/import/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/saved_query/import/"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/saved_query/import/"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/saved_query/import/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/saved_query/import/') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"formData\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"passwords\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/saved_query/import/";

    let form = reqwest::multipart::Form::new()
        .text("formData", "")
        .text("overwrite", "")
        .text("passwords", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/saved_query/import/ \
  --header 'content-type: multipart/form-data' \
  --form formData= \
  --form overwrite= \
  --form passwords=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="formData"


-----011000010111000001101001
Content-Disposition: form-data; name="overwrite"


-----011000010111000001101001
Content-Disposition: form-data; name="passwords"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/saved_query/import/ \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="formData"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="overwrite"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="passwords"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/saved_query/import/
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "formData",
    "value": ""
  ],
  [
    "name": "overwrite",
    "value": ""
  ],
  [
    "name": "passwords",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/saved_query/import/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Create a report schedule
{{baseUrl}}/report/
BODY json
{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/");

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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/report/" {:content-type :json
                                                    :form-params {:active false
                                                                  :chart 0
                                                                  :context_markdown ""
                                                                  :creation_method ""
                                                                  :crontab ""
                                                                  :dashboard 0
                                                                  :database 0
                                                                  :description ""
                                                                  :grace_period 0
                                                                  :log_retention 0
                                                                  :name ""
                                                                  :owners []
                                                                  :recipients [{:recipient_config_json {:target ""}
                                                                                :type ""}]
                                                                  :report_format ""
                                                                  :sql ""
                                                                  :timezone ""
                                                                  :type ""
                                                                  :validator_config_json {:op ""
                                                                                          :threshold 0}
                                                                  :validator_type ""
                                                                  :working_timeout 0}})
require "http/client"

url = "{{baseUrl}}/report/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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}}/report/"),
    Content = new StringContent("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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}}/report/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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/report/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 530

{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/report/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/report/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/report/")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}")
  .asString();
const data = JSON.stringify({
  active: false,
  chart: 0,
  context_markdown: '',
  creation_method: '',
  crontab: '',
  dashboard: 0,
  database: 0,
  description: '',
  grace_period: 0,
  log_retention: 0,
  name: '',
  owners: [],
  recipients: [
    {
      recipient_config_json: {
        target: ''
      },
      type: ''
    }
  ],
  report_format: '',
  sql: '',
  timezone: '',
  type: '',
  validator_config_json: {
    op: '',
    threshold: 0
  },
  validator_type: '',
  working_timeout: 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}}/report/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/report/',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    chart: 0,
    context_markdown: '',
    creation_method: '',
    crontab: '',
    dashboard: 0,
    database: 0,
    description: '',
    grace_period: 0,
    log_retention: 0,
    name: '',
    owners: [],
    recipients: [{recipient_config_json: {target: ''}, type: ''}],
    report_format: '',
    sql: '',
    timezone: '',
    type: '',
    validator_config_json: {op: '', threshold: 0},
    validator_type: '',
    working_timeout: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"chart":0,"context_markdown":"","creation_method":"","crontab":"","dashboard":0,"database":0,"description":"","grace_period":0,"log_retention":0,"name":"","owners":[],"recipients":[{"recipient_config_json":{"target":""},"type":""}],"report_format":"","sql":"","timezone":"","type":"","validator_config_json":{"op":"","threshold":0},"validator_type":"","working_timeout":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}}/report/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "chart": 0,\n  "context_markdown": "",\n  "creation_method": "",\n  "crontab": "",\n  "dashboard": 0,\n  "database": 0,\n  "description": "",\n  "grace_period": 0,\n  "log_retention": 0,\n  "name": "",\n  "owners": [],\n  "recipients": [\n    {\n      "recipient_config_json": {\n        "target": ""\n      },\n      "type": ""\n    }\n  ],\n  "report_format": "",\n  "sql": "",\n  "timezone": "",\n  "type": "",\n  "validator_config_json": {\n    "op": "",\n    "threshold": 0\n  },\n  "validator_type": "",\n  "working_timeout": 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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/report/")
  .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/report/',
  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({
  active: false,
  chart: 0,
  context_markdown: '',
  creation_method: '',
  crontab: '',
  dashboard: 0,
  database: 0,
  description: '',
  grace_period: 0,
  log_retention: 0,
  name: '',
  owners: [],
  recipients: [{recipient_config_json: {target: ''}, type: ''}],
  report_format: '',
  sql: '',
  timezone: '',
  type: '',
  validator_config_json: {op: '', threshold: 0},
  validator_type: '',
  working_timeout: 0
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/report/',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    chart: 0,
    context_markdown: '',
    creation_method: '',
    crontab: '',
    dashboard: 0,
    database: 0,
    description: '',
    grace_period: 0,
    log_retention: 0,
    name: '',
    owners: [],
    recipients: [{recipient_config_json: {target: ''}, type: ''}],
    report_format: '',
    sql: '',
    timezone: '',
    type: '',
    validator_config_json: {op: '', threshold: 0},
    validator_type: '',
    working_timeout: 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}}/report/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  active: false,
  chart: 0,
  context_markdown: '',
  creation_method: '',
  crontab: '',
  dashboard: 0,
  database: 0,
  description: '',
  grace_period: 0,
  log_retention: 0,
  name: '',
  owners: [],
  recipients: [
    {
      recipient_config_json: {
        target: ''
      },
      type: ''
    }
  ],
  report_format: '',
  sql: '',
  timezone: '',
  type: '',
  validator_config_json: {
    op: '',
    threshold: 0
  },
  validator_type: '',
  working_timeout: 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}}/report/',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    chart: 0,
    context_markdown: '',
    creation_method: '',
    crontab: '',
    dashboard: 0,
    database: 0,
    description: '',
    grace_period: 0,
    log_retention: 0,
    name: '',
    owners: [],
    recipients: [{recipient_config_json: {target: ''}, type: ''}],
    report_format: '',
    sql: '',
    timezone: '',
    type: '',
    validator_config_json: {op: '', threshold: 0},
    validator_type: '',
    working_timeout: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"chart":0,"context_markdown":"","creation_method":"","crontab":"","dashboard":0,"database":0,"description":"","grace_period":0,"log_retention":0,"name":"","owners":[],"recipients":[{"recipient_config_json":{"target":""},"type":""}],"report_format":"","sql":"","timezone":"","type":"","validator_config_json":{"op":"","threshold":0},"validator_type":"","working_timeout":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 = @{ @"active": @NO,
                              @"chart": @0,
                              @"context_markdown": @"",
                              @"creation_method": @"",
                              @"crontab": @"",
                              @"dashboard": @0,
                              @"database": @0,
                              @"description": @"",
                              @"grace_period": @0,
                              @"log_retention": @0,
                              @"name": @"",
                              @"owners": @[  ],
                              @"recipients": @[ @{ @"recipient_config_json": @{ @"target": @"" }, @"type": @"" } ],
                              @"report_format": @"",
                              @"sql": @"",
                              @"timezone": @"",
                              @"type": @"",
                              @"validator_config_json": @{ @"op": @"", @"threshold": @0 },
                              @"validator_type": @"",
                              @"working_timeout": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/report/"]
                                                       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}}/report/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/",
  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([
    'active' => null,
    'chart' => 0,
    'context_markdown' => '',
    'creation_method' => '',
    'crontab' => '',
    'dashboard' => 0,
    'database' => 0,
    'description' => '',
    'grace_period' => 0,
    'log_retention' => 0,
    'name' => '',
    'owners' => [
        
    ],
    'recipients' => [
        [
                'recipient_config_json' => [
                                'target' => ''
                ],
                'type' => ''
        ]
    ],
    'report_format' => '',
    'sql' => '',
    'timezone' => '',
    'type' => '',
    'validator_config_json' => [
        'op' => '',
        'threshold' => 0
    ],
    'validator_type' => '',
    'working_timeout' => 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}}/report/', [
  'body' => '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/report/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'chart' => 0,
  'context_markdown' => '',
  'creation_method' => '',
  'crontab' => '',
  'dashboard' => 0,
  'database' => 0,
  'description' => '',
  'grace_period' => 0,
  'log_retention' => 0,
  'name' => '',
  'owners' => [
    
  ],
  'recipients' => [
    [
        'recipient_config_json' => [
                'target' => ''
        ],
        'type' => ''
    ]
  ],
  'report_format' => '',
  'sql' => '',
  'timezone' => '',
  'type' => '',
  'validator_config_json' => [
    'op' => '',
    'threshold' => 0
  ],
  'validator_type' => '',
  'working_timeout' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'active' => null,
  'chart' => 0,
  'context_markdown' => '',
  'creation_method' => '',
  'crontab' => '',
  'dashboard' => 0,
  'database' => 0,
  'description' => '',
  'grace_period' => 0,
  'log_retention' => 0,
  'name' => '',
  'owners' => [
    
  ],
  'recipients' => [
    [
        'recipient_config_json' => [
                'target' => ''
        ],
        'type' => ''
    ]
  ],
  'report_format' => '',
  'sql' => '',
  'timezone' => '',
  'type' => '',
  'validator_config_json' => [
    'op' => '',
    'threshold' => 0
  ],
  'validator_type' => '',
  'working_timeout' => 0
]));
$request->setRequestUrl('{{baseUrl}}/report/');
$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}}/report/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/report/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/"

payload = {
    "active": False,
    "chart": 0,
    "context_markdown": "",
    "creation_method": "",
    "crontab": "",
    "dashboard": 0,
    "database": 0,
    "description": "",
    "grace_period": 0,
    "log_retention": 0,
    "name": "",
    "owners": [],
    "recipients": [
        {
            "recipient_config_json": { "target": "" },
            "type": ""
        }
    ],
    "report_format": "",
    "sql": "",
    "timezone": "",
    "type": "",
    "validator_config_json": {
        "op": "",
        "threshold": 0
    },
    "validator_type": "",
    "working_timeout": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/"

payload <- "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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}}/report/")

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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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/report/') do |req|
  req.body = "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/";

    let payload = json!({
        "active": false,
        "chart": 0,
        "context_markdown": "",
        "creation_method": "",
        "crontab": "",
        "dashboard": 0,
        "database": 0,
        "description": "",
        "grace_period": 0,
        "log_retention": 0,
        "name": "",
        "owners": (),
        "recipients": (
            json!({
                "recipient_config_json": json!({"target": ""}),
                "type": ""
            })
        ),
        "report_format": "",
        "sql": "",
        "timezone": "",
        "type": "",
        "validator_config_json": json!({
            "op": "",
            "threshold": 0
        }),
        "validator_type": "",
        "working_timeout": 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);
}

curl --request POST \
  --url {{baseUrl}}/report/ \
  --header 'content-type: application/json' \
  --data '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}'
echo '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}' |  \
  http POST {{baseUrl}}/report/ \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "chart": 0,\n  "context_markdown": "",\n  "creation_method": "",\n  "crontab": "",\n  "dashboard": 0,\n  "database": 0,\n  "description": "",\n  "grace_period": 0,\n  "log_retention": 0,\n  "name": "",\n  "owners": [],\n  "recipients": [\n    {\n      "recipient_config_json": {\n        "target": ""\n      },\n      "type": ""\n    }\n  ],\n  "report_format": "",\n  "sql": "",\n  "timezone": "",\n  "type": "",\n  "validator_config_json": {\n    "op": "",\n    "threshold": 0\n  },\n  "validator_type": "",\n  "working_timeout": 0\n}' \
  --output-document \
  - {{baseUrl}}/report/
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    [
      "recipient_config_json": ["target": ""],
      "type": ""
    ]
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": [
    "op": "",
    "threshold": 0
  ],
  "validator_type": "",
  "working_timeout": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "result": {
    "crontab": "*/5 * * * *",
    "description": "Daily sales dashboard to marketing",
    "grace_period": 14400,
    "log_retention": 90,
    "name": "Daily dashboard email",
    "sql": "SELECT value FROM time_series_table",
    "working_timeout": 3600
  }
}
DELETE Delete a report schedule
{{baseUrl}}/report/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/report/:pk")
require "http/client"

url = "{{baseUrl}}/report/:pk"

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}}/report/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/:pk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/:pk"

	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/report/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/report/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/:pk"))
    .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}}/report/:pk")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/report/:pk")
  .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}}/report/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/report/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/:pk';
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}}/report/:pk',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/:pk")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/:pk',
  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}}/report/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/report/:pk');

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}}/report/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/:pk';
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}}/report/:pk"]
                                                       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}}/report/:pk" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/:pk",
  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}}/report/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/report/:pk');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/:pk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/:pk' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/:pk' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/report/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/:pk"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/:pk"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/:pk")

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/report/:pk') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/:pk";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/report/:pk
http DELETE {{baseUrl}}/report/:pk
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/report/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/:pk")! 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()
DELETE Deletes multiple report schedules in a bulk operation.
{{baseUrl}}/report/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/report/")
require "http/client"

url = "{{baseUrl}}/report/"

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}}/report/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/"

	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/report/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/report/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/"))
    .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}}/report/")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/report/")
  .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}}/report/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/report/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/';
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}}/report/',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/',
  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}}/report/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/report/');

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}}/report/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/';
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}}/report/"]
                                                       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}}/report/" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/",
  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}}/report/');

echo $response->getBody();
setUrl('{{baseUrl}}/report/');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/report/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/")

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/report/') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/report/
http DELETE {{baseUrl}}/report/
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/report/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/")! 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()
GET Get a list of report schedule logs, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/report/:pk/log/
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/:pk/log/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/report/:pk/log/")
require "http/client"

url = "{{baseUrl}}/report/:pk/log/"

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}}/report/:pk/log/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/:pk/log/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/:pk/log/"

	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/report/:pk/log/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/report/:pk/log/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/:pk/log/"))
    .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}}/report/:pk/log/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/report/:pk/log/")
  .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}}/report/:pk/log/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/report/:pk/log/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/:pk/log/';
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}}/report/:pk/log/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/:pk/log/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/:pk/log/',
  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}}/report/:pk/log/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/report/:pk/log/');

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}}/report/:pk/log/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/:pk/log/';
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}}/report/:pk/log/"]
                                                       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}}/report/:pk/log/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/:pk/log/",
  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}}/report/:pk/log/');

echo $response->getBody();
setUrl('{{baseUrl}}/report/:pk/log/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/:pk/log/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/:pk/log/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/:pk/log/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/report/:pk/log/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/:pk/log/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/:pk/log/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/:pk/log/")

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/report/:pk/log/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/:pk/log/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/report/:pk/log/
http GET {{baseUrl}}/report/:pk/log/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/report/:pk/log/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/:pk/log/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Get a list of report schedules, use Rison or JSON query parameters for filtering, sorting, pagination and for selecting specific columns and metadata.
{{baseUrl}}/report/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/report/")
require "http/client"

url = "{{baseUrl}}/report/"

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}}/report/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/"

	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/report/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/report/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/"))
    .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}}/report/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/report/")
  .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}}/report/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/report/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/';
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}}/report/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/',
  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}}/report/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/report/');

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}}/report/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/';
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}}/report/"]
                                                       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}}/report/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/",
  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}}/report/');

echo $response->getBody();
setUrl('{{baseUrl}}/report/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/report/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/")

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/report/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/report/
http GET {{baseUrl}}/report/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/report/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "list_title": "List Items"
}
GET Get a report schedule log
{{baseUrl}}/report/:pk/log/:log_id
QUERY PARAMS
pk
log_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/:pk/log/:log_id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/report/:pk/log/:log_id")
require "http/client"

url = "{{baseUrl}}/report/:pk/log/:log_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}}/report/:pk/log/:log_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/:pk/log/:log_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/:pk/log/:log_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/report/:pk/log/:log_id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/report/:pk/log/:log_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/:pk/log/:log_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}}/report/:pk/log/:log_id")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/report/:pk/log/:log_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}}/report/:pk/log/:log_id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/report/:pk/log/:log_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/:pk/log/:log_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}}/report/:pk/log/:log_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/:pk/log/:log_id")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/:pk/log/:log_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}}/report/:pk/log/:log_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}}/report/:pk/log/:log_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}}/report/:pk/log/:log_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/:pk/log/:log_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}}/report/:pk/log/:log_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}}/report/:pk/log/:log_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/:pk/log/:log_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}}/report/:pk/log/:log_id');

echo $response->getBody();
setUrl('{{baseUrl}}/report/:pk/log/:log_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/:pk/log/:log_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/:pk/log/:log_id' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/:pk/log/:log_id' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/report/:pk/log/:log_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/:pk/log/:log_id"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/:pk/log/:log_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/:pk/log/:log_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/report/:pk/log/:log_id') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/:pk/log/:log_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/report/:pk/log/:log_id
http GET {{baseUrl}}/report/:pk/log/:log_id
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/report/:pk/log/:log_id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/:pk/log/:log_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()
GET Get a report schedule
{{baseUrl}}/report/:pk
QUERY PARAMS
pk
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/:pk");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/report/:pk")
require "http/client"

url = "{{baseUrl}}/report/:pk"

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}}/report/:pk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/:pk");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/:pk"

	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/report/:pk HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/report/:pk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/:pk"))
    .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}}/report/:pk")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/report/:pk")
  .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}}/report/:pk');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/report/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/:pk';
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}}/report/:pk',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/:pk")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/:pk',
  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}}/report/:pk'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/report/:pk');

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}}/report/:pk'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/:pk';
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}}/report/:pk"]
                                                       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}}/report/:pk" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/:pk",
  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}}/report/:pk');

echo $response->getBody();
setUrl('{{baseUrl}}/report/:pk');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/:pk');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/:pk' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/:pk' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/report/:pk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/:pk"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/:pk"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/:pk")

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/report/:pk') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/:pk";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/report/:pk
http GET {{baseUrl}}/report/:pk
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/report/:pk
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "description_columns": {
    "column_name": "A Nice description for the column"
  },
  "label_columns": {
    "column_name": "A Nice label for the column"
  },
  "show_title": "Show Item Details"
}
GET Get metadata information about this API resource (4)
{{baseUrl}}/report/_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/_info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/report/_info")
require "http/client"

url = "{{baseUrl}}/report/_info"

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}}/report/_info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/_info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/_info"

	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/report/_info HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/report/_info")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/_info"))
    .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}}/report/_info")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/report/_info")
  .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}}/report/_info');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/report/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/_info';
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}}/report/_info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/_info")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/_info',
  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}}/report/_info'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/report/_info');

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}}/report/_info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/_info';
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}}/report/_info"]
                                                       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}}/report/_info" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/_info",
  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}}/report/_info');

echo $response->getBody();
setUrl('{{baseUrl}}/report/_info');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/_info' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/report/_info")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/_info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/_info"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/_info")

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/report/_info') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/_info";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/report/_info
http GET {{baseUrl}}/report/_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/report/_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/_info")! 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()
PUT Update a report schedule
{{baseUrl}}/report/:pk
QUERY PARAMS
pk
BODY json
{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/:pk");

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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/report/:pk" {:content-type :json
                                                      :form-params {:active false
                                                                    :chart 0
                                                                    :context_markdown ""
                                                                    :creation_method ""
                                                                    :crontab ""
                                                                    :dashboard 0
                                                                    :database 0
                                                                    :description ""
                                                                    :grace_period 0
                                                                    :log_retention 0
                                                                    :name ""
                                                                    :owners []
                                                                    :recipients [{:recipient_config_json {:target ""}
                                                                                  :type ""}]
                                                                    :report_format ""
                                                                    :sql ""
                                                                    :timezone ""
                                                                    :type ""
                                                                    :validator_config_json {:op ""
                                                                                            :threshold 0}
                                                                    :validator_type ""
                                                                    :working_timeout 0}})
require "http/client"

url = "{{baseUrl}}/report/:pk"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\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}}/report/:pk"),
    Content = new StringContent("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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}}/report/:pk");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/:pk"

	payload := strings.NewReader("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\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/report/:pk HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 530

{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/report/:pk")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/:pk"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/report/:pk")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/report/:pk")
  .header("content-type", "application/json")
  .body("{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}")
  .asString();
const data = JSON.stringify({
  active: false,
  chart: 0,
  context_markdown: '',
  creation_method: '',
  crontab: '',
  dashboard: 0,
  database: 0,
  description: '',
  grace_period: 0,
  log_retention: 0,
  name: '',
  owners: [],
  recipients: [
    {
      recipient_config_json: {
        target: ''
      },
      type: ''
    }
  ],
  report_format: '',
  sql: '',
  timezone: '',
  type: '',
  validator_config_json: {
    op: '',
    threshold: 0
  },
  validator_type: '',
  working_timeout: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/report/:pk');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/report/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    chart: 0,
    context_markdown: '',
    creation_method: '',
    crontab: '',
    dashboard: 0,
    database: 0,
    description: '',
    grace_period: 0,
    log_retention: 0,
    name: '',
    owners: [],
    recipients: [{recipient_config_json: {target: ''}, type: ''}],
    report_format: '',
    sql: '',
    timezone: '',
    type: '',
    validator_config_json: {op: '', threshold: 0},
    validator_type: '',
    working_timeout: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"chart":0,"context_markdown":"","creation_method":"","crontab":"","dashboard":0,"database":0,"description":"","grace_period":0,"log_retention":0,"name":"","owners":[],"recipients":[{"recipient_config_json":{"target":""},"type":""}],"report_format":"","sql":"","timezone":"","type":"","validator_config_json":{"op":"","threshold":0},"validator_type":"","working_timeout":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}}/report/:pk',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "active": false,\n  "chart": 0,\n  "context_markdown": "",\n  "creation_method": "",\n  "crontab": "",\n  "dashboard": 0,\n  "database": 0,\n  "description": "",\n  "grace_period": 0,\n  "log_retention": 0,\n  "name": "",\n  "owners": [],\n  "recipients": [\n    {\n      "recipient_config_json": {\n        "target": ""\n      },\n      "type": ""\n    }\n  ],\n  "report_format": "",\n  "sql": "",\n  "timezone": "",\n  "type": "",\n  "validator_config_json": {\n    "op": "",\n    "threshold": 0\n  },\n  "validator_type": "",\n  "working_timeout": 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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/report/:pk")
  .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/report/:pk',
  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({
  active: false,
  chart: 0,
  context_markdown: '',
  creation_method: '',
  crontab: '',
  dashboard: 0,
  database: 0,
  description: '',
  grace_period: 0,
  log_retention: 0,
  name: '',
  owners: [],
  recipients: [{recipient_config_json: {target: ''}, type: ''}],
  report_format: '',
  sql: '',
  timezone: '',
  type: '',
  validator_config_json: {op: '', threshold: 0},
  validator_type: '',
  working_timeout: 0
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/report/:pk',
  headers: {'content-type': 'application/json'},
  body: {
    active: false,
    chart: 0,
    context_markdown: '',
    creation_method: '',
    crontab: '',
    dashboard: 0,
    database: 0,
    description: '',
    grace_period: 0,
    log_retention: 0,
    name: '',
    owners: [],
    recipients: [{recipient_config_json: {target: ''}, type: ''}],
    report_format: '',
    sql: '',
    timezone: '',
    type: '',
    validator_config_json: {op: '', threshold: 0},
    validator_type: '',
    working_timeout: 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('PUT', '{{baseUrl}}/report/:pk');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  active: false,
  chart: 0,
  context_markdown: '',
  creation_method: '',
  crontab: '',
  dashboard: 0,
  database: 0,
  description: '',
  grace_period: 0,
  log_retention: 0,
  name: '',
  owners: [],
  recipients: [
    {
      recipient_config_json: {
        target: ''
      },
      type: ''
    }
  ],
  report_format: '',
  sql: '',
  timezone: '',
  type: '',
  validator_config_json: {
    op: '',
    threshold: 0
  },
  validator_type: '',
  working_timeout: 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: 'PUT',
  url: '{{baseUrl}}/report/:pk',
  headers: {'content-type': 'application/json'},
  data: {
    active: false,
    chart: 0,
    context_markdown: '',
    creation_method: '',
    crontab: '',
    dashboard: 0,
    database: 0,
    description: '',
    grace_period: 0,
    log_retention: 0,
    name: '',
    owners: [],
    recipients: [{recipient_config_json: {target: ''}, type: ''}],
    report_format: '',
    sql: '',
    timezone: '',
    type: '',
    validator_config_json: {op: '', threshold: 0},
    validator_type: '',
    working_timeout: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/:pk';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"active":false,"chart":0,"context_markdown":"","creation_method":"","crontab":"","dashboard":0,"database":0,"description":"","grace_period":0,"log_retention":0,"name":"","owners":[],"recipients":[{"recipient_config_json":{"target":""},"type":""}],"report_format":"","sql":"","timezone":"","type":"","validator_config_json":{"op":"","threshold":0},"validator_type":"","working_timeout":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 = @{ @"active": @NO,
                              @"chart": @0,
                              @"context_markdown": @"",
                              @"creation_method": @"",
                              @"crontab": @"",
                              @"dashboard": @0,
                              @"database": @0,
                              @"description": @"",
                              @"grace_period": @0,
                              @"log_retention": @0,
                              @"name": @"",
                              @"owners": @[  ],
                              @"recipients": @[ @{ @"recipient_config_json": @{ @"target": @"" }, @"type": @"" } ],
                              @"report_format": @"",
                              @"sql": @"",
                              @"timezone": @"",
                              @"type": @"",
                              @"validator_config_json": @{ @"op": @"", @"threshold": @0 },
                              @"validator_type": @"",
                              @"working_timeout": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/report/:pk"]
                                                       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}}/report/:pk" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/:pk",
  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([
    'active' => null,
    'chart' => 0,
    'context_markdown' => '',
    'creation_method' => '',
    'crontab' => '',
    'dashboard' => 0,
    'database' => 0,
    'description' => '',
    'grace_period' => 0,
    'log_retention' => 0,
    'name' => '',
    'owners' => [
        
    ],
    'recipients' => [
        [
                'recipient_config_json' => [
                                'target' => ''
                ],
                'type' => ''
        ]
    ],
    'report_format' => '',
    'sql' => '',
    'timezone' => '',
    'type' => '',
    'validator_config_json' => [
        'op' => '',
        'threshold' => 0
    ],
    'validator_type' => '',
    'working_timeout' => 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('PUT', '{{baseUrl}}/report/:pk', [
  'body' => '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/report/:pk');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'active' => null,
  'chart' => 0,
  'context_markdown' => '',
  'creation_method' => '',
  'crontab' => '',
  'dashboard' => 0,
  'database' => 0,
  'description' => '',
  'grace_period' => 0,
  'log_retention' => 0,
  'name' => '',
  'owners' => [
    
  ],
  'recipients' => [
    [
        'recipient_config_json' => [
                'target' => ''
        ],
        'type' => ''
    ]
  ],
  'report_format' => '',
  'sql' => '',
  'timezone' => '',
  'type' => '',
  'validator_config_json' => [
    'op' => '',
    'threshold' => 0
  ],
  'validator_type' => '',
  'working_timeout' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'active' => null,
  'chart' => 0,
  'context_markdown' => '',
  'creation_method' => '',
  'crontab' => '',
  'dashboard' => 0,
  'database' => 0,
  'description' => '',
  'grace_period' => 0,
  'log_retention' => 0,
  'name' => '',
  'owners' => [
    
  ],
  'recipients' => [
    [
        'recipient_config_json' => [
                'target' => ''
        ],
        'type' => ''
    ]
  ],
  'report_format' => '',
  'sql' => '',
  'timezone' => '',
  'type' => '',
  'validator_config_json' => [
    'op' => '',
    'threshold' => 0
  ],
  'validator_type' => '',
  'working_timeout' => 0
]));
$request->setRequestUrl('{{baseUrl}}/report/:pk');
$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}}/report/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/:pk' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/report/:pk", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/:pk"

payload = {
    "active": False,
    "chart": 0,
    "context_markdown": "",
    "creation_method": "",
    "crontab": "",
    "dashboard": 0,
    "database": 0,
    "description": "",
    "grace_period": 0,
    "log_retention": 0,
    "name": "",
    "owners": [],
    "recipients": [
        {
            "recipient_config_json": { "target": "" },
            "type": ""
        }
    ],
    "report_format": "",
    "sql": "",
    "timezone": "",
    "type": "",
    "validator_config_json": {
        "op": "",
        "threshold": 0
    },
    "validator_type": "",
    "working_timeout": 0
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/:pk"

payload <- "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\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}}/report/:pk")

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  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 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.put('/baseUrl/report/:pk') do |req|
  req.body = "{\n  \"active\": false,\n  \"chart\": 0,\n  \"context_markdown\": \"\",\n  \"creation_method\": \"\",\n  \"crontab\": \"\",\n  \"dashboard\": 0,\n  \"database\": 0,\n  \"description\": \"\",\n  \"grace_period\": 0,\n  \"log_retention\": 0,\n  \"name\": \"\",\n  \"owners\": [],\n  \"recipients\": [\n    {\n      \"recipient_config_json\": {\n        \"target\": \"\"\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"report_format\": \"\",\n  \"sql\": \"\",\n  \"timezone\": \"\",\n  \"type\": \"\",\n  \"validator_config_json\": {\n    \"op\": \"\",\n    \"threshold\": 0\n  },\n  \"validator_type\": \"\",\n  \"working_timeout\": 0\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}}/report/:pk";

    let payload = json!({
        "active": false,
        "chart": 0,
        "context_markdown": "",
        "creation_method": "",
        "crontab": "",
        "dashboard": 0,
        "database": 0,
        "description": "",
        "grace_period": 0,
        "log_retention": 0,
        "name": "",
        "owners": (),
        "recipients": (
            json!({
                "recipient_config_json": json!({"target": ""}),
                "type": ""
            })
        ),
        "report_format": "",
        "sql": "",
        "timezone": "",
        "type": "",
        "validator_config_json": json!({
            "op": "",
            "threshold": 0
        }),
        "validator_type": "",
        "working_timeout": 0
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/report/:pk \
  --header 'content-type: application/json' \
  --data '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}'
echo '{
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    {
      "recipient_config_json": {
        "target": ""
      },
      "type": ""
    }
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": {
    "op": "",
    "threshold": 0
  },
  "validator_type": "",
  "working_timeout": 0
}' |  \
  http PUT {{baseUrl}}/report/:pk \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "active": false,\n  "chart": 0,\n  "context_markdown": "",\n  "creation_method": "",\n  "crontab": "",\n  "dashboard": 0,\n  "database": 0,\n  "description": "",\n  "grace_period": 0,\n  "log_retention": 0,\n  "name": "",\n  "owners": [],\n  "recipients": [\n    {\n      "recipient_config_json": {\n        "target": ""\n      },\n      "type": ""\n    }\n  ],\n  "report_format": "",\n  "sql": "",\n  "timezone": "",\n  "type": "",\n  "validator_config_json": {\n    "op": "",\n    "threshold": 0\n  },\n  "validator_type": "",\n  "working_timeout": 0\n}' \
  --output-document \
  - {{baseUrl}}/report/:pk
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "active": false,
  "chart": 0,
  "context_markdown": "",
  "creation_method": "",
  "crontab": "",
  "dashboard": 0,
  "database": 0,
  "description": "",
  "grace_period": 0,
  "log_retention": 0,
  "name": "",
  "owners": [],
  "recipients": [
    [
      "recipient_config_json": ["target": ""],
      "type": ""
    ]
  ],
  "report_format": "",
  "sql": "",
  "timezone": "",
  "type": "",
  "validator_config_json": [
    "op": "",
    "threshold": 0
  ],
  "validator_type": "",
  "working_timeout": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/:pk")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "result": {
    "description": "Daily sales dashboard to marketing",
    "grace_period": 14400,
    "log_retention": 90,
    "sql": "SELECT value FROM time_series_table",
    "working_timeout": 3600
  }
}
GET get -report-related--column_name
{{baseUrl}}/report/related/:column_name
QUERY PARAMS
column_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/report/related/:column_name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/report/related/:column_name")
require "http/client"

url = "{{baseUrl}}/report/related/:column_name"

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}}/report/related/:column_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/report/related/:column_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/report/related/:column_name"

	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/report/related/:column_name HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/report/related/:column_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/report/related/:column_name"))
    .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}}/report/related/:column_name")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/report/related/:column_name")
  .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}}/report/related/:column_name');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/report/related/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/report/related/:column_name';
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}}/report/related/:column_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/report/related/:column_name")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/report/related/:column_name',
  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}}/report/related/:column_name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/report/related/:column_name');

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}}/report/related/:column_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/report/related/:column_name';
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}}/report/related/:column_name"]
                                                       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}}/report/related/:column_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/report/related/:column_name",
  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}}/report/related/:column_name');

echo $response->getBody();
setUrl('{{baseUrl}}/report/related/:column_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/report/related/:column_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/report/related/:column_name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/report/related/:column_name' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/report/related/:column_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/report/related/:column_name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/report/related/:column_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/report/related/:column_name")

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/report/related/:column_name') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/report/related/:column_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/report/related/:column_name
http GET {{baseUrl}}/report/related/:column_name
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/report/related/:column_name
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/report/related/:column_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Authenticate and get a JWT access and refresh token
{{baseUrl}}/security/login
BODY json
{
  "password": "",
  "provider": "",
  "refresh": false,
  "username": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/security/login");

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  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/security/login" {:content-type :json
                                                           :form-params {:password "complex-password"
                                                                         :provider "db"
                                                                         :refresh true
                                                                         :username "admin"}})
require "http/client"

url = "{{baseUrl}}/security/login"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\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}}/security/login"),
    Content = new StringContent("{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\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}}/security/login");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/security/login"

	payload := strings.NewReader("{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\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/security/login HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "password": "complex-password",
  "provider": "db",
  "refresh": true,
  "username": "admin"
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/security/login")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/security/login"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\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  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/security/login")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/security/login")
  .header("content-type", "application/json")
  .body("{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}")
  .asString();
const data = JSON.stringify({
  password: 'complex-password',
  provider: 'db',
  refresh: true,
  username: 'admin'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/security/login');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/security/login',
  headers: {'content-type': 'application/json'},
  data: {password: 'complex-password', provider: 'db', refresh: true, username: 'admin'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/security/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"password":"complex-password","provider":"db","refresh":true,"username":"admin"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/security/login',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "password": "complex-password",\n  "provider": "db",\n  "refresh": true,\n  "username": "admin"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/security/login")
  .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/security/login',
  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({password: 'complex-password', provider: 'db', refresh: true, username: 'admin'}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/security/login',
  headers: {'content-type': 'application/json'},
  body: {password: 'complex-password', provider: 'db', refresh: true, username: 'admin'},
  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}}/security/login');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  password: 'complex-password',
  provider: 'db',
  refresh: true,
  username: 'admin'
});

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}}/security/login',
  headers: {'content-type': 'application/json'},
  data: {password: 'complex-password', provider: 'db', refresh: true, username: 'admin'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/security/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"password":"complex-password","provider":"db","refresh":true,"username":"admin"}'
};

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 = @{ @"password": @"complex-password",
                              @"provider": @"db",
                              @"refresh": @YES,
                              @"username": @"admin" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/security/login"]
                                                       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}}/security/login" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/security/login",
  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([
    'password' => 'complex-password',
    'provider' => 'db',
    'refresh' => null,
    'username' => 'admin'
  ]),
  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}}/security/login', [
  'body' => '{
  "password": "complex-password",
  "provider": "db",
  "refresh": true,
  "username": "admin"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/security/login');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'password' => 'complex-password',
  'provider' => 'db',
  'refresh' => null,
  'username' => 'admin'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'password' => 'complex-password',
  'provider' => 'db',
  'refresh' => null,
  'username' => 'admin'
]));
$request->setRequestUrl('{{baseUrl}}/security/login');
$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}}/security/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "password": "complex-password",
  "provider": "db",
  "refresh": true,
  "username": "admin"
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/security/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "password": "complex-password",
  "provider": "db",
  "refresh": true,
  "username": "admin"
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/security/login", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/security/login"

payload = {
    "password": "complex-password",
    "provider": "db",
    "refresh": True,
    "username": "admin"
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/security/login"

payload <- "{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\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}}/security/login")

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  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\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/security/login') do |req|
  req.body = "{\n  \"password\": \"complex-password\",\n  \"provider\": \"db\",\n  \"refresh\": true,\n  \"username\": \"admin\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/security/login";

    let payload = json!({
        "password": "complex-password",
        "provider": "db",
        "refresh": true,
        "username": "admin"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/security/login \
  --header 'content-type: application/json' \
  --data '{
  "password": "complex-password",
  "provider": "db",
  "refresh": true,
  "username": "admin"
}'
echo '{
  "password": "complex-password",
  "provider": "db",
  "refresh": true,
  "username": "admin"
}' |  \
  http POST {{baseUrl}}/security/login \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "password": "complex-password",\n  "provider": "db",\n  "refresh": true,\n  "username": "admin"\n}' \
  --output-document \
  - {{baseUrl}}/security/login
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "password": "complex-password",
  "provider": "db",
  "refresh": true,
  "username": "admin"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/security/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
GET Fetch the CSRF token
{{baseUrl}}/security/csrf_token/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/security/csrf_token/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/security/csrf_token/")
require "http/client"

url = "{{baseUrl}}/security/csrf_token/"

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}}/security/csrf_token/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/security/csrf_token/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/security/csrf_token/"

	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/security/csrf_token/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/security/csrf_token/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/security/csrf_token/"))
    .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}}/security/csrf_token/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/security/csrf_token/")
  .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}}/security/csrf_token/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/security/csrf_token/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/security/csrf_token/';
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}}/security/csrf_token/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/security/csrf_token/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/security/csrf_token/',
  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}}/security/csrf_token/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/security/csrf_token/');

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}}/security/csrf_token/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/security/csrf_token/';
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}}/security/csrf_token/"]
                                                       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}}/security/csrf_token/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/security/csrf_token/",
  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}}/security/csrf_token/');

echo $response->getBody();
setUrl('{{baseUrl}}/security/csrf_token/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/security/csrf_token/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/security/csrf_token/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/security/csrf_token/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/security/csrf_token/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/security/csrf_token/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/security/csrf_token/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/security/csrf_token/")

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/security/csrf_token/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/security/csrf_token/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/security/csrf_token/
http GET {{baseUrl}}/security/csrf_token/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/security/csrf_token/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/security/csrf_token/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Use the refresh token to get a new JWT access token
{{baseUrl}}/security/refresh
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/security/refresh");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/security/refresh")
require "http/client"

url = "{{baseUrl}}/security/refresh"

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}}/security/refresh"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/security/refresh");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/security/refresh"

	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/security/refresh HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/security/refresh")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/security/refresh"))
    .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}}/security/refresh")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/security/refresh")
  .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}}/security/refresh');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/security/refresh'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/security/refresh';
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}}/security/refresh',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/security/refresh")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/security/refresh',
  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}}/security/refresh'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/security/refresh');

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}}/security/refresh'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/security/refresh';
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}}/security/refresh"]
                                                       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}}/security/refresh" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/security/refresh",
  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}}/security/refresh');

echo $response->getBody();
setUrl('{{baseUrl}}/security/refresh');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/security/refresh');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/security/refresh' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/security/refresh' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/security/refresh")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/security/refresh"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/security/refresh"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/security/refresh")

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/security/refresh') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/security/refresh";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/security/refresh
http POST {{baseUrl}}/security/refresh
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/security/refresh
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/security/refresh")! 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()