Otoroshi Admin API

POST Create a new api key for a group

{{baseUrl}}/api/groups/:groupId/apikeys

QUERY PARAMS

groupId

BODY json

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys");

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/groups/:groupId/apikeys" {:content-type :json
                                                                        :form-params {:authorizedEntities []
                                                                                      :clientId ""
                                                                                      :clientName ""
                                                                                      :clientSecret ""
                                                                                      :dailyQuota 0
                                                                                      :enabled false
                                                                                      :metadata {}
                                                                                      :monthlyQuota 0
                                                                                      :throttlingQuota 0}})

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/groups/:groupId/apikeys"),
    Content = new StringContent("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/groups/:groupId/apikeys");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys"

	payload := strings.NewReader("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/groups/:groupId/apikeys HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 192

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/groups/:groupId/apikeys")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:groupId/apikeys"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/groups/:groupId/apikeys")
  .header("content-type", "application/json")
  .body("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .asString();

const data = JSON.stringify({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/groups/:groupId/apikeys');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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}}/api/groups/:groupId/apikeys',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys")
  .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/api/groups/:groupId/apikeys',
  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({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys',
  headers: {'content-type': 'application/json'},
  body: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 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}}/api/groups/:groupId/apikeys');

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

req.type('json');
req.send({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/groups/:groupId/apikeys',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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 = @{ @"authorizedEntities": @[  ],
                              @"clientId": @"",
                              @"clientName": @"",
                              @"clientSecret": @"",
                              @"dailyQuota": @0,
                              @"enabled": @NO,
                              @"metadata": @{  },
                              @"monthlyQuota": @0,
                              @"throttlingQuota": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/groups/:groupId/apikeys"]
                                                       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}}/api/groups/:groupId/apikeys" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys",
  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([
    'authorizedEntities' => [
        
    ],
    'clientId' => '',
    'clientName' => '',
    'clientSecret' => '',
    'dailyQuota' => 0,
    'enabled' => null,
    'metadata' => [
        
    ],
    'monthlyQuota' => 0,
    'throttlingQuota' => 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}}/api/groups/:groupId/apikeys', [
  'body' => '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));

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

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

append(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys');
$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}}/api/groups/:groupId/apikeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

import http.client

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

payload = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}"

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

conn.request("POST", "/baseUrl/api/groups/:groupId/apikeys", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys"

payload = {
    "authorizedEntities": [],
    "clientId": "",
    "clientName": "",
    "clientSecret": "",
    "dailyQuota": 0,
    "enabled": False,
    "metadata": {},
    "monthlyQuota": 0,
    "throttlingQuota": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys"

payload <- "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/groups/:groupId/apikeys")

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/groups/:groupId/apikeys') do |req|
  req.body = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "authorizedEntities": (),
        "clientId": "",
        "clientName": "",
        "clientSecret": "",
        "dailyQuota": 0,
        "enabled": false,
        "metadata": json!({}),
        "monthlyQuota": 0,
        "throttlingQuota": 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}}/api/groups/:groupId/apikeys \
  --header 'content-type: application/json' \
  --data '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

echo '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}' |  \
  http POST {{baseUrl}}/api/groups/:groupId/apikeys \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": [],
  "monthlyQuota": 0,
  "throttlingQuota": 0
] as [String : Any]

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

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

POST Create a new api key for a service

{{baseUrl}}/api/services/:serviceId/apikeys

QUERY PARAMS

serviceId

BODY json

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys");

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/services/:serviceId/apikeys" {:content-type :json
                                                                            :form-params {:authorizedEntities []
                                                                                          :clientId ""
                                                                                          :clientName ""
                                                                                          :clientSecret ""
                                                                                          :dailyQuota 0
                                                                                          :enabled false
                                                                                          :metadata {}
                                                                                          :monthlyQuota 0
                                                                                          :throttlingQuota 0}})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/services/:serviceId/apikeys"),
    Content = new StringContent("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/services/:serviceId/apikeys");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys"

	payload := strings.NewReader("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/services/:serviceId/apikeys HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 192

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/services/:serviceId/apikeys")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/apikeys"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/services/:serviceId/apikeys")
  .header("content-type", "application/json")
  .body("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .asString();

const data = JSON.stringify({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/services/:serviceId/apikeys');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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}}/api/services/:serviceId/apikeys',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys")
  .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/api/services/:serviceId/apikeys',
  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({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys',
  headers: {'content-type': 'application/json'},
  body: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 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}}/api/services/:serviceId/apikeys');

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

req.type('json');
req.send({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/services/:serviceId/apikeys',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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 = @{ @"authorizedEntities": @[  ],
                              @"clientId": @"",
                              @"clientName": @"",
                              @"clientSecret": @"",
                              @"dailyQuota": @0,
                              @"enabled": @NO,
                              @"metadata": @{  },
                              @"monthlyQuota": @0,
                              @"throttlingQuota": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId/apikeys"]
                                                       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}}/api/services/:serviceId/apikeys" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys",
  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([
    'authorizedEntities' => [
        
    ],
    'clientId' => '',
    'clientName' => '',
    'clientSecret' => '',
    'dailyQuota' => 0,
    'enabled' => null,
    'metadata' => [
        
    ],
    'monthlyQuota' => 0,
    'throttlingQuota' => 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}}/api/services/:serviceId/apikeys', [
  'body' => '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));

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

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

append(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys');
$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}}/api/services/:serviceId/apikeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

import http.client

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

payload = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}"

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

conn.request("POST", "/baseUrl/api/services/:serviceId/apikeys", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys"

payload = {
    "authorizedEntities": [],
    "clientId": "",
    "clientName": "",
    "clientSecret": "",
    "dailyQuota": 0,
    "enabled": False,
    "metadata": {},
    "monthlyQuota": 0,
    "throttlingQuota": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys"

payload <- "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/services/:serviceId/apikeys")

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/services/:serviceId/apikeys') do |req|
  req.body = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "authorizedEntities": (),
        "clientId": "",
        "clientName": "",
        "clientSecret": "",
        "dailyQuota": 0,
        "enabled": false,
        "metadata": json!({}),
        "monthlyQuota": 0,
        "throttlingQuota": 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}}/api/services/:serviceId/apikeys \
  --header 'content-type: application/json' \
  --data '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

echo '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}' |  \
  http POST {{baseUrl}}/api/services/:serviceId/apikeys \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": [],
  "monthlyQuota": 0,
  "throttlingQuota": 0
] as [String : Any]

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

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

DELETE Delete an api key (DELETE)

{{baseUrl}}/api/services/:serviceId/apikeys/:clientId

QUERY PARAMS

serviceId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

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

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

	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/api/services/:serviceId/apikeys/:clientId HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .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}}/api/services/:serviceId/apikeys/:clientId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId'
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
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}}/api/services/:serviceId/apikeys/:clientId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId'
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
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}}/api/services/:serviceId/apikeys/:clientId"]
                                                       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}}/api/services/:serviceId/apikeys/:clientId" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId",
  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}}/api/services/:serviceId/apikeys/:clientId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/api/services/:serviceId/apikeys/:clientId")

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")

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/api/services/:serviceId/apikeys/:clientId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId";

    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}}/api/services/:serviceId/apikeys/:clientId

http DELETE {{baseUrl}}/api/services/:serviceId/apikeys/:clientId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys/:clientId

import Foundation

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

DELETE Delete an api key

{{baseUrl}}/api/groups/:groupId/apikeys/:clientId

QUERY PARAMS

groupId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

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

var client = new RestClient("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

	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/api/groups/:groupId/apikeys/:clientId HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .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}}/api/groups/:groupId/apikeys/:clientId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId'
};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
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}}/api/groups/:groupId/apikeys/:clientId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId'
};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
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}}/api/groups/:groupId/apikeys/:clientId"]
                                                       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}}/api/groups/:groupId/apikeys/:clientId" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId",
  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}}/api/groups/:groupId/apikeys/:clientId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/api/groups/:groupId/apikeys/:clientId")

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")

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/api/groups/:groupId/apikeys/:clientId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId";

    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}}/api/groups/:groupId/apikeys/:clientId

http DELETE {{baseUrl}}/api/groups/:groupId/apikeys/:clientId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys/:clientId

import Foundation

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get all api keys for the group of a service (GET)

{{baseUrl}}/api/services/:serviceId/apikeys

QUERY PARAMS

serviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/services/:serviceId/apikeys")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys"

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

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/apikeys");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys"

	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/api/services/:serviceId/apikeys HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/services/:serviceId/apikeys")
  .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}}/api/services/:serviceId/apikeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys'
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys';
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}}/api/services/:serviceId/apikeys',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/services/:serviceId/apikeys');

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}}/api/services/:serviceId/apikeys'
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys';
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}}/api/services/:serviceId/apikeys"]
                                                       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}}/api/services/:serviceId/apikeys" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys",
  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}}/api/services/:serviceId/apikeys');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/apikeys' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/services/:serviceId/apikeys")

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/apikeys")

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/api/services/:serviceId/apikeys') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/api/services/:serviceId/apikeys

http GET {{baseUrl}}/api/services/:serviceId/apikeys

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys

import Foundation

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

[
  {
    "authorizedEntities": [
      "a string value"
    ],
    "clientId": "a string value",
    "clientName": "a string value",
    "clientSecret": "a string value",
    "dailyQuota": 123,
    "enabled": true,
    "metadata": {
      "key": "value"
    },
    "monthlyQuota": 123,
    "throttlingQuota": 123
  }
]

GET Get all api keys for the group of a service

{{baseUrl}}/api/groups/:groupId/apikeys

QUERY PARAMS

groupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/groups/:groupId/apikeys")

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys"

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

var client = new RestClient("{{baseUrl}}/api/groups/:groupId/apikeys");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys"

	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/api/groups/:groupId/apikeys HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/groups/:groupId/apikeys")
  .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}}/api/groups/:groupId/apikeys');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/groups/:groupId/apikeys'};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys';
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}}/api/groups/:groupId/apikeys',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/groups/:groupId/apikeys');

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}}/api/groups/:groupId/apikeys'};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys';
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}}/api/groups/:groupId/apikeys"]
                                                       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}}/api/groups/:groupId/apikeys" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys",
  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}}/api/groups/:groupId/apikeys');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:groupId/apikeys' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/groups/:groupId/apikeys")

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:groupId/apikeys")

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/api/groups/:groupId/apikeys') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/api/groups/:groupId/apikeys

http GET {{baseUrl}}/api/groups/:groupId/apikeys

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys

import Foundation

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

[
  {
    "authorizedEntities": [
      "a string value"
    ],
    "clientId": "a string value",
    "clientName": "a string value",
    "clientSecret": "a string value",
    "dailyQuota": 123,
    "enabled": true,
    "metadata": {
      "key": "value"
    },
    "monthlyQuota": 123,
    "throttlingQuota": 123
  }
]

GET Get all api keys

{{baseUrl}}/api/apikeys

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/apikeys")

require "http/client"

url = "{{baseUrl}}/api/apikeys"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/apikeys"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/apikeys")
  .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}}/api/apikeys');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/api/apikeys');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/apikeys' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/apikeys' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/apikeys")

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

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

import requests

url = "{{baseUrl}}/api/apikeys"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/apikeys"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/apikeys")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/api/apikeys

http GET {{baseUrl}}/api/apikeys

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/apikeys

import Foundation

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

[
  {
    "authorizedEntities": [
      "a string value"
    ],
    "clientId": "a string value",
    "clientName": "a string value",
    "clientSecret": "a string value",
    "dailyQuota": 123,
    "enabled": true,
    "metadata": {
      "key": "value"
    },
    "monthlyQuota": 123,
    "throttlingQuota": 123
  }
]

GET Get an api key (GET)

{{baseUrl}}/api/services/:serviceId/apikeys/:clientId

QUERY PARAMS

serviceId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

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

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

	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/api/services/:serviceId/apikeys/:clientId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"))
    .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}}/api/services/:serviceId/apikeys/:clientId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .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}}/api/services/:serviceId/apikeys/:clientId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId'
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
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}}/api/services/:serviceId/apikeys/:clientId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId'
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
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}}/api/services/:serviceId/apikeys/:clientId"]
                                                       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}}/api/services/:serviceId/apikeys/:clientId" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId",
  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}}/api/services/:serviceId/apikeys/:clientId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/services/:serviceId/apikeys/:clientId")

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")

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/api/services/:serviceId/apikeys/:clientId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId";

    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}}/api/services/:serviceId/apikeys/:clientId

http GET {{baseUrl}}/api/services/:serviceId/apikeys/:clientId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys/:clientId

import Foundation

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

GET Get an api key

{{baseUrl}}/api/groups/:groupId/apikeys/:clientId

QUERY PARAMS

groupId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

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

var client = new RestClient("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

	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/api/groups/:groupId/apikeys/:clientId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"))
    .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}}/api/groups/:groupId/apikeys/:clientId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .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}}/api/groups/:groupId/apikeys/:clientId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId'
};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
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}}/api/groups/:groupId/apikeys/:clientId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId'
};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
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}}/api/groups/:groupId/apikeys/:clientId"]
                                                       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}}/api/groups/:groupId/apikeys/:clientId" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId",
  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}}/api/groups/:groupId/apikeys/:clientId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/groups/:groupId/apikeys/:clientId")

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")

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/api/groups/:groupId/apikeys/:clientId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId";

    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}}/api/groups/:groupId/apikeys/:clientId

http GET {{baseUrl}}/api/groups/:groupId/apikeys/:clientId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys/:clientId

import Foundation

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

GET Get the group of an api key

{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group

QUERY PARAMS

serviceId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group"

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

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group"

	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/api/services/:serviceId/apikeys/:clientId/group HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group"))
    .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}}/api/services/:serviceId/apikeys/:clientId/group")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group")
  .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}}/api/services/:serviceId/apikeys/:clientId/group');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group'
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group';
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}}/api/services/:serviceId/apikeys/:clientId/group',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group');

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}}/api/services/:serviceId/apikeys/:clientId/group'
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group';
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}}/api/services/:serviceId/apikeys/:clientId/group"]
                                                       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}}/api/services/:serviceId/apikeys/:clientId/group" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group",
  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}}/api/services/:serviceId/apikeys/:clientId/group');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/services/:serviceId/apikeys/:clientId/group")

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group")

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/api/services/:serviceId/apikeys/:clientId/group') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group";

    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}}/api/services/:serviceId/apikeys/:clientId/group

http GET {{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/group")! 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": "a string value",
  "id": "a string value",
  "name": "a string value"
}

GET Get the quota state of an api key (GET)

{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas

QUERY PARAMS

serviceId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

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

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

	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/api/services/:serviceId/apikeys/:clientId/quotas HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"))
    .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}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .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}}/api/services/:serviceId/apikeys/:clientId/quotas');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas'
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas';
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}}/api/services/:serviceId/apikeys/:clientId/quotas',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas');

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}}/api/services/:serviceId/apikeys/:clientId/quotas'
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas';
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}}/api/services/:serviceId/apikeys/:clientId/quotas"]
                                                       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}}/api/services/:serviceId/apikeys/:clientId/quotas" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas",
  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}}/api/services/:serviceId/apikeys/:clientId/quotas');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/services/:serviceId/apikeys/:clientId/quotas")

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")

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/api/services/:serviceId/apikeys/:clientId/quotas') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas";

    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}}/api/services/:serviceId/apikeys/:clientId/quotas

http GET {{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")! 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

{
  "authorizedCallsPerDay": 123,
  "authorizedCallsPerMonth": 123,
  "authorizedCallsPerSec": 123,
  "currentCallsPerDay": 123,
  "currentCallsPerMonth": 123,
  "currentCallsPerSec": 123,
  "remainingCallsPerDay": 123,
  "remainingCallsPerMonth": 123,
  "remainingCallsPerSec": 123
}

GET Get the quota state of an api key

{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas

QUERY PARAMS

groupId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

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

var client = new RestClient("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

	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/api/groups/:groupId/apikeys/:clientId/quotas HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"))
    .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}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .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}}/api/groups/:groupId/apikeys/:clientId/quotas');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas'
};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas';
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}}/api/groups/:groupId/apikeys/:clientId/quotas',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas');

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}}/api/groups/:groupId/apikeys/:clientId/quotas'
};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas';
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}}/api/groups/:groupId/apikeys/:clientId/quotas"]
                                                       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}}/api/groups/:groupId/apikeys/:clientId/quotas" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas",
  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}}/api/groups/:groupId/apikeys/:clientId/quotas');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/groups/:groupId/apikeys/:clientId/quotas")

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")

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/api/groups/:groupId/apikeys/:clientId/quotas') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas";

    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}}/api/groups/:groupId/apikeys/:clientId/quotas

http GET {{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")! 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

{
  "authorizedCallsPerDay": 123,
  "authorizedCallsPerMonth": 123,
  "authorizedCallsPerSec": 123,
  "currentCallsPerDay": 123,
  "currentCallsPerMonth": 123,
  "currentCallsPerSec": 123,
  "remainingCallsPerDay": 123,
  "remainingCallsPerMonth": 123,
  "remainingCallsPerSec": 123
}

DELETE Reset the quota state of an api key (DELETE)

{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas

QUERY PARAMS

serviceId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

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

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

	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/api/services/:serviceId/apikeys/:clientId/quotas HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"))
    .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}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .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}}/api/services/:serviceId/apikeys/:clientId/quotas');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas'
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas';
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}}/api/services/:serviceId/apikeys/:clientId/quotas',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas');

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}}/api/services/:serviceId/apikeys/:clientId/quotas'
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas';
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}}/api/services/:serviceId/apikeys/:clientId/quotas"]
                                                       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}}/api/services/:serviceId/apikeys/:clientId/quotas" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas",
  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}}/api/services/:serviceId/apikeys/:clientId/quotas');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/api/services/:serviceId/apikeys/:clientId/quotas")

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")

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/api/services/:serviceId/apikeys/:clientId/quotas') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas";

    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}}/api/services/:serviceId/apikeys/:clientId/quotas

http DELETE {{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId/quotas")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "authorizedCallsPerDay": 123,
  "authorizedCallsPerMonth": 123,
  "authorizedCallsPerSec": 123,
  "currentCallsPerDay": 123,
  "currentCallsPerMonth": 123,
  "currentCallsPerSec": 123,
  "remainingCallsPerDay": 123,
  "remainingCallsPerMonth": 123,
  "remainingCallsPerSec": 123
}

DELETE Reset the quota state of an api key

{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas

QUERY PARAMS

groupId

clientId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

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

var client = new RestClient("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

	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/api/groups/:groupId/apikeys/:clientId/quotas HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"))
    .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}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .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}}/api/groups/:groupId/apikeys/:clientId/quotas');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas'
};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas';
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}}/api/groups/:groupId/apikeys/:clientId/quotas',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas');

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}}/api/groups/:groupId/apikeys/:clientId/quotas'
};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas';
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}}/api/groups/:groupId/apikeys/:clientId/quotas"]
                                                       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}}/api/groups/:groupId/apikeys/:clientId/quotas" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas",
  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}}/api/groups/:groupId/apikeys/:clientId/quotas');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/api/groups/:groupId/apikeys/:clientId/quotas")

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")

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/api/groups/:groupId/apikeys/:clientId/quotas') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas";

    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}}/api/groups/:groupId/apikeys/:clientId/quotas

http DELETE {{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId/quotas")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "authorizedCallsPerDay": 123,
  "authorizedCallsPerMonth": 123,
  "authorizedCallsPerSec": 123,
  "currentCallsPerDay": 123,
  "currentCallsPerMonth": 123,
  "currentCallsPerSec": 123,
  "remainingCallsPerDay": 123,
  "remainingCallsPerMonth": 123,
  "remainingCallsPerSec": 123
}

PUT Update an api key (PUT)

{{baseUrl}}/api/services/:serviceId/apikeys/:clientId

QUERY PARAMS

serviceId

clientId

BODY json

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId");

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId" {:content-type :json
                                                                                     :form-params {:authorizedEntities []
                                                                                                   :clientId ""
                                                                                                   :clientName ""
                                                                                                   :clientSecret ""
                                                                                                   :dailyQuota 0
                                                                                                   :enabled false
                                                                                                   :metadata {}
                                                                                                   :monthlyQuota 0
                                                                                                   :throttlingQuota 0}})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/services/:serviceId/apikeys/:clientId"),
    Content = new StringContent("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/services/:serviceId/apikeys/:clientId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

	payload := strings.NewReader("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/services/:serviceId/apikeys/:clientId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 192

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .header("content-type", "application/json")
  .body("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .asString();

const data = JSON.stringify({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/services/:serviceId/apikeys/:clientId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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}}/api/services/:serviceId/apikeys/:clientId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .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/api/services/:serviceId/apikeys/:clientId',
  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({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  body: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 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}}/api/services/:serviceId/apikeys/:clientId');

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

req.type('json');
req.send({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/services/:serviceId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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 = @{ @"authorizedEntities": @[  ],
                              @"clientId": @"",
                              @"clientName": @"",
                              @"clientSecret": @"",
                              @"dailyQuota": @0,
                              @"enabled": @NO,
                              @"metadata": @{  },
                              @"monthlyQuota": @0,
                              @"throttlingQuota": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"]
                                                       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}}/api/services/:serviceId/apikeys/:clientId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId",
  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([
    'authorizedEntities' => [
        
    ],
    'clientId' => '',
    'clientName' => '',
    'clientSecret' => '',
    'dailyQuota' => 0,
    'enabled' => null,
    'metadata' => [
        
    ],
    'monthlyQuota' => 0,
    'throttlingQuota' => 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}}/api/services/:serviceId/apikeys/:clientId', [
  'body' => '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));

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

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

append(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$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}}/api/services/:serviceId/apikeys/:clientId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

import http.client

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

payload = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}"

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

conn.request("PUT", "/baseUrl/api/services/:serviceId/apikeys/:clientId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

payload = {
    "authorizedEntities": [],
    "clientId": "",
    "clientName": "",
    "clientSecret": "",
    "dailyQuota": 0,
    "enabled": False,
    "metadata": {},
    "monthlyQuota": 0,
    "throttlingQuota": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

payload <- "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/services/:serviceId/apikeys/:clientId")

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/services/:serviceId/apikeys/:clientId') do |req|
  req.body = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/services/:serviceId/apikeys/:clientId";

    let payload = json!({
        "authorizedEntities": (),
        "clientId": "",
        "clientName": "",
        "clientSecret": "",
        "dailyQuota": 0,
        "enabled": false,
        "metadata": json!({}),
        "monthlyQuota": 0,
        "throttlingQuota": 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}}/api/services/:serviceId/apikeys/:clientId \
  --header 'content-type: application/json' \
  --data '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

echo '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}' |  \
  http PUT {{baseUrl}}/api/services/:serviceId/apikeys/:clientId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys/:clientId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": [],
  "monthlyQuota": 0,
  "throttlingQuota": 0
] as [String : Any]

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

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

PATCH Update an api key with a diff (PATCH)

{{baseUrl}}/api/services/:serviceId/apikeys/:clientId

QUERY PARAMS

serviceId

clientId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId" {:content-type :json
                                                                                       :form-params [{:op ""
                                                                                                      :path ""
                                                                                                      :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/services/:serviceId/apikeys/:clientId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

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

}

PATCH /baseUrl/api/services/:serviceId/apikeys/:clientId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId/apikeys/:clientId',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');

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

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

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

const url = '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/services/:serviceId/apikeys/:clientId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

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

 "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

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

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

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId/apikeys/:clientId');
$request->setRequestMethod('PATCH');
$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}}/api/services/:serviceId/apikeys/:clientId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/apikeys/:clientId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

conn.request("PATCH", "/baseUrl/api/services/:serviceId/apikeys/:clientId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/apikeys/:clientId")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/services/:serviceId/apikeys/:clientId') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/apikeys/:clientId";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/services/:serviceId/apikeys/:clientId \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/services/:serviceId/apikeys/:clientId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/apikeys/:clientId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

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

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

PATCH Update an api key with a diff

{{baseUrl}}/api/groups/:groupId/apikeys/:clientId

QUERY PARAMS

groupId

clientId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId" {:content-type :json
                                                                                   :form-params [{:op ""
                                                                                                  :path ""
                                                                                                  :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/groups/:groupId/apikeys/:clientId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

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

}

PATCH /baseUrl/api/groups/:groupId/apikeys/:clientId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/groups/:groupId/apikeys/:clientId',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');

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

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/groups/:groupId/apikeys/:clientId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

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

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

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$request->setRequestMethod('PATCH');
$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}}/api/groups/:groupId/apikeys/:clientId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

conn.request("PATCH", "/baseUrl/api/groups/:groupId/apikeys/:clientId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/groups/:groupId/apikeys/:clientId') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/groups/:groupId/apikeys/:clientId \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/groups/:groupId/apikeys/:clientId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys/:clientId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

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

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

PUT Update an api key

{{baseUrl}}/api/groups/:groupId/apikeys/:clientId

QUERY PARAMS

groupId

clientId

BODY json

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId");

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId" {:content-type :json
                                                                                 :form-params {:authorizedEntities []
                                                                                               :clientId ""
                                                                                               :clientName ""
                                                                                               :clientSecret ""
                                                                                               :dailyQuota 0
                                                                                               :enabled false
                                                                                               :metadata {}
                                                                                               :monthlyQuota 0
                                                                                               :throttlingQuota 0}})

require "http/client"

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/groups/:groupId/apikeys/:clientId"),
    Content = new StringContent("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/groups/:groupId/apikeys/:clientId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

	payload := strings.NewReader("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/groups/:groupId/apikeys/:clientId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 192

{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .header("content-type", "application/json")
  .body("{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
  .asString();

const data = JSON.stringify({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/groups/:groupId/apikeys/:clientId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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}}/api/groups/:groupId/apikeys/:clientId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:groupId/apikeys/:clientId")
  .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/api/groups/:groupId/apikeys/:clientId',
  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({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  body: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 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}}/api/groups/:groupId/apikeys/:clientId');

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

req.type('json');
req.send({
  authorizedEntities: [],
  clientId: '',
  clientName: '',
  clientSecret: '',
  dailyQuota: 0,
  enabled: false,
  metadata: {},
  monthlyQuota: 0,
  throttlingQuota: 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}}/api/groups/:groupId/apikeys/:clientId',
  headers: {'content-type': 'application/json'},
  data: {
    authorizedEntities: [],
    clientId: '',
    clientName: '',
    clientSecret: '',
    dailyQuota: 0,
    enabled: false,
    metadata: {},
    monthlyQuota: 0,
    throttlingQuota: 0
  }
};

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

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

const url = '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":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 = @{ @"authorizedEntities": @[  ],
                              @"clientId": @"",
                              @"clientName": @"",
                              @"clientSecret": @"",
                              @"dailyQuota": @0,
                              @"enabled": @NO,
                              @"metadata": @{  },
                              @"monthlyQuota": @0,
                              @"throttlingQuota": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"]
                                                       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}}/api/groups/:groupId/apikeys/:clientId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}" in

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

 "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId",
  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([
    'authorizedEntities' => [
        
    ],
    'clientId' => '',
    'clientName' => '',
    'clientSecret' => '',
    'dailyQuota' => 0,
    'enabled' => null,
    'metadata' => [
        
    ],
    'monthlyQuota' => 0,
    'throttlingQuota' => 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}}/api/groups/:groupId/apikeys/:clientId', [
  'body' => '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));

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

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

append(json_encode([
  'authorizedEntities' => [
    
  ],
  'clientId' => '',
  'clientName' => '',
  'clientSecret' => '',
  'dailyQuota' => 0,
  'enabled' => null,
  'metadata' => [
    
  ],
  'monthlyQuota' => 0,
  'throttlingQuota' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/groups/:groupId/apikeys/:clientId');
$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}}/api/groups/:groupId/apikeys/:clientId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:groupId/apikeys/:clientId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

import http.client

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

payload = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 0\n}"

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

conn.request("PUT", "/baseUrl/api/groups/:groupId/apikeys/:clientId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

payload = {
    "authorizedEntities": [],
    "clientId": "",
    "clientName": "",
    "clientSecret": "",
    "dailyQuota": 0,
    "enabled": False,
    "metadata": {},
    "monthlyQuota": 0,
    "throttlingQuota": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:groupId/apikeys/:clientId"

payload <- "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/groups/:groupId/apikeys/:clientId")

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  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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/api/groups/:groupId/apikeys/:clientId') do |req|
  req.body = "{\n  \"authorizedEntities\": [],\n  \"clientId\": \"\",\n  \"clientName\": \"\",\n  \"clientSecret\": \"\",\n  \"dailyQuota\": 0,\n  \"enabled\": false,\n  \"metadata\": {},\n  \"monthlyQuota\": 0,\n  \"throttlingQuota\": 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}}/api/groups/:groupId/apikeys/:clientId";

    let payload = json!({
        "authorizedEntities": (),
        "clientId": "",
        "clientName": "",
        "clientSecret": "",
        "dailyQuota": 0,
        "enabled": false,
        "metadata": json!({}),
        "monthlyQuota": 0,
        "throttlingQuota": 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}}/api/groups/:groupId/apikeys/:clientId \
  --header 'content-type: application/json' \
  --data '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}'

echo '{
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": {},
  "monthlyQuota": 0,
  "throttlingQuota": 0
}' |  \
  http PUT {{baseUrl}}/api/groups/:groupId/apikeys/:clientId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizedEntities": [],\n  "clientId": "",\n  "clientName": "",\n  "clientSecret": "",\n  "dailyQuota": 0,\n  "enabled": false,\n  "metadata": {},\n  "monthlyQuota": 0,\n  "throttlingQuota": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/groups/:groupId/apikeys/:clientId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizedEntities": [],
  "clientId": "",
  "clientName": "",
  "clientSecret": "",
  "dailyQuota": 0,
  "enabled": false,
  "metadata": [],
  "monthlyQuota": 0,
  "throttlingQuota": 0
] as [String : Any]

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

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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

POST Create one global auth. module config

{{baseUrl}}/api/auths

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/auths")

require "http/client"

url = "{{baseUrl}}/api/auths"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auths"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auths"))
    .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}}/api/auths")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/auths")
  .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}}/api/auths');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/auths'};

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

const url = '{{baseUrl}}/api/auths';
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}}/api/auths',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/auths")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/auths');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auths' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auths' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/api/auths")

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

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

import requests

url = "{{baseUrl}}/api/auths"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auths"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auths")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/api/auths

http POST {{baseUrl}}/api/auths

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/auths

import Foundation

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

DELETE Delete one global auth. module config

{{baseUrl}}/api/auths/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auths/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/auths/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auths/: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/api/auths/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/auths/: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}}/api/auths/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/auths/:id'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/auths/: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/api/auths/: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}}/api/auths/: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}}/api/auths/: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}}/api/auths/:id'};

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

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

const url = '{{baseUrl}}/api/auths/: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}}/api/auths/: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}}/api/auths/:id" in

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

 "{{baseUrl}}/api/auths/: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}}/api/auths/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/auths/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auths/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auths/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/api/auths/:id")

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

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

import requests

url = "{{baseUrl}}/api/auths/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auths/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auths/: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/api/auths/: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}}/api/auths/: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}}/api/auths/:id

http DELETE {{baseUrl}}/api/auths/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/auths/:id

import Foundation

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get all global auth. module configs

{{baseUrl}}/api/auths

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/auths")

require "http/client"

url = "{{baseUrl}}/api/auths"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auths"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/auths")
  .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}}/api/auths');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/api/auths');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auths' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auths' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/auths")

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

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

import requests

url = "{{baseUrl}}/api/auths"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auths"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auths")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/api/auths

http GET {{baseUrl}}/api/auths

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/auths

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/auths")! 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 one global auth. module configs

{{baseUrl}}/api/auths/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auths/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/auths/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auths/: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/api/auths/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/auths/: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}}/api/auths/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/auths/:id'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/auths/:id")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/api/auths/: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}}/api/auths/: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}}/api/auths/:id" in

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

 "{{baseUrl}}/api/auths/: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}}/api/auths/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/auths/:id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auths/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auths/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/auths/:id")

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

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

import requests

url = "{{baseUrl}}/api/auths/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auths/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auths/: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/api/auths/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/auths/: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}}/api/auths/:id

http GET {{baseUrl}}/api/auths/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/auths/:id

import Foundation

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

PUT Update one global auth. module config (PUT)

{{baseUrl}}/api/auths/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auths/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/auths/:id")

require "http/client"

url = "{{baseUrl}}/api/auths/:id"

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

var client = new RestClient("{{baseUrl}}/api/auths/:id");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/auths/:id"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auths/:id"))
    .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}}/api/auths/:id")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/auths/: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('PUT', '{{baseUrl}}/api/auths/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/api/auths/:id'};

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

const url = '{{baseUrl}}/api/auths/:id';
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}}/api/auths/:id',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/auths/:id")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/auths/: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: 'PUT', url: '{{baseUrl}}/api/auths/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/auths/: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: 'PUT', url: '{{baseUrl}}/api/auths/:id'};

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

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

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

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

 "{{baseUrl}}/api/auths/:id",
  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}}/api/auths/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/auths/:id');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/api/auths/:id');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auths/:id' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auths/:id' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/api/auths/:id")

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

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

import requests

url = "{{baseUrl}}/api/auths/:id"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auths/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auths/:id")

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/api/auths/: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}}/api/auths/:id";

    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}}/api/auths/:id

http PUT {{baseUrl}}/api/auths/:id

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/api/auths/:id

import Foundation

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

PATCH Update one global auth. module config

{{baseUrl}}/api/auths/:id

QUERY PARAMS

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auths/: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  {\n    \"path\": \"a string value\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/api/auths/:id" {:content-type :json
                                                           :form-params [{:path "a string value"}]})

require "http/client"

url = "{{baseUrl}}/api/auths/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"path\": \"a string value\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/auths/:id"),
    Content = new StringContent("[\n  {\n    \"path\": \"a string value\"\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}}/api/auths/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"path\": \"a string value\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/auths/:id"

	payload := strings.NewReader("[\n  {\n    \"path\": \"a string value\"\n  }\n]")

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

}

PATCH /baseUrl/api/auths/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 40

[
  {
    "path": "a string value"
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/auths/:id")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"path\": \"a string value\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auths/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"path\": \"a string value\"\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  {\n    \"path\": \"a string value\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/auths/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/api/auths/:id")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"path\": \"a string value\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    path: 'a string value'
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/api/auths/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/auths/:id',
  headers: {'content-type': 'application/json'},
  data: [{path: 'a string value'}]
};

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

const url = '{{baseUrl}}/api/auths/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"path":"a string value"}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/auths/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "path": "a string value"\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  {\n    \"path\": \"a string value\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/auths/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/auths/: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([{path: 'a string value'}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/auths/:id',
  headers: {'content-type': 'application/json'},
  body: [{path: 'a string value'}],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/auths/:id');

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

req.type('json');
req.send([
  {
    path: 'a string value'
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/auths/:id',
  headers: {'content-type': 'application/json'},
  data: [{path: 'a string value'}]
};

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

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

const url = '{{baseUrl}}/api/auths/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"path":"a string value"}]'
};

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 = @[ @{ @"path": @"a string value" } ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/auths/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/auths/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"path\": \"a string value\"\n  }\n]" in

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

 "{{baseUrl}}/api/auths/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'path' => 'a string value'
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/auths/:id', [
  'body' => '[
  {
    "path": "a string value"
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/auths/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'path' => 'a string value'
  ]
]));

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

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

append(json_encode([
  [
    'path' => 'a string value'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/auths/:id');
$request->setRequestMethod('PATCH');
$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}}/api/auths/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "path": "a string value"
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auths/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "path": "a string value"
  }
]'

import http.client

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

payload = "[\n  {\n    \"path\": \"a string value\"\n  }\n]"

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

conn.request("PATCH", "/baseUrl/api/auths/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/auths/:id"

payload = [{ "path": "a string value" }]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auths/:id"

payload <- "[\n  {\n    \"path\": \"a string value\"\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auths/:id")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"path\": \"a string value\"\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.patch('/baseUrl/api/auths/:id') do |req|
  req.body = "[\n  {\n    \"path\": \"a string value\"\n  }\n]"
end

puts response.status
puts response.body

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

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

    let payload = (json!({"path": "a string value"}));

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/auths/:id \
  --header 'content-type: application/json' \
  --data '[
  {
    "path": "a string value"
  }
]'

echo '[
  {
    "path": "a string value"
  }
]' |  \
  http PATCH {{baseUrl}}/api/auths/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "path": "a string value"\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/auths/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [["path": "a string value"]] as [String : Any]

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

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

{{baseUrl}}/api/certificates

BODY json

{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/certificates" {:content-type :json
                                                             :form-params {:autoRenew ""
                                                                           :ca ""
                                                                           :caRef ""
                                                                           :chain ""
                                                                           :domain ""
                                                                           :from ""
                                                                           :id ""
                                                                           :privateKey ""
                                                                           :selfSigned ""
                                                                           :subject ""
                                                                           :to ""
                                                                           :valid ""}})

require "http/client"

url = "{{baseUrl}}/api/certificates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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}}/api/certificates"),
    Content = new StringContent("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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}}/api/certificates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/certificates"

	payload := strings.NewReader("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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/api/certificates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 189

{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/certificates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/certificates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/certificates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/certificates")
  .header("content-type", "application/json")
  .body("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  autoRenew: '',
  ca: '',
  caRef: '',
  chain: '',
  domain: '',
  from: '',
  id: '',
  privateKey: '',
  selfSigned: '',
  subject: '',
  to: '',
  valid: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/certificates',
  headers: {'content-type': 'application/json'},
  data: {
    autoRenew: '',
    ca: '',
    caRef: '',
    chain: '',
    domain: '',
    from: '',
    id: '',
    privateKey: '',
    selfSigned: '',
    subject: '',
    to: '',
    valid: ''
  }
};

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

const url = '{{baseUrl}}/api/certificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"autoRenew":"","ca":"","caRef":"","chain":"","domain":"","from":"","id":"","privateKey":"","selfSigned":"","subject":"","to":"","valid":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/certificates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "autoRenew": "",\n  "ca": "",\n  "caRef": "",\n  "chain": "",\n  "domain": "",\n  "from": "",\n  "id": "",\n  "privateKey": "",\n  "selfSigned": "",\n  "subject": "",\n  "to": "",\n  "valid": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/certificates")
  .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/api/certificates',
  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({
  autoRenew: '',
  ca: '',
  caRef: '',
  chain: '',
  domain: '',
  from: '',
  id: '',
  privateKey: '',
  selfSigned: '',
  subject: '',
  to: '',
  valid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/certificates',
  headers: {'content-type': 'application/json'},
  body: {
    autoRenew: '',
    ca: '',
    caRef: '',
    chain: '',
    domain: '',
    from: '',
    id: '',
    privateKey: '',
    selfSigned: '',
    subject: '',
    to: '',
    valid: ''
  },
  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}}/api/certificates');

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

req.type('json');
req.send({
  autoRenew: '',
  ca: '',
  caRef: '',
  chain: '',
  domain: '',
  from: '',
  id: '',
  privateKey: '',
  selfSigned: '',
  subject: '',
  to: '',
  valid: ''
});

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}}/api/certificates',
  headers: {'content-type': 'application/json'},
  data: {
    autoRenew: '',
    ca: '',
    caRef: '',
    chain: '',
    domain: '',
    from: '',
    id: '',
    privateKey: '',
    selfSigned: '',
    subject: '',
    to: '',
    valid: ''
  }
};

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

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

const url = '{{baseUrl}}/api/certificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"autoRenew":"","ca":"","caRef":"","chain":"","domain":"","from":"","id":"","privateKey":"","selfSigned":"","subject":"","to":"","valid":""}'
};

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 = @{ @"autoRenew": @"",
                              @"ca": @"",
                              @"caRef": @"",
                              @"chain": @"",
                              @"domain": @"",
                              @"from": @"",
                              @"id": @"",
                              @"privateKey": @"",
                              @"selfSigned": @"",
                              @"subject": @"",
                              @"to": @"",
                              @"valid": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/certificates"]
                                                       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}}/api/certificates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}" in

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

 "{{baseUrl}}/api/certificates",
  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([
    'autoRenew' => '',
    'ca' => '',
    'caRef' => '',
    'chain' => '',
    'domain' => '',
    'from' => '',
    'id' => '',
    'privateKey' => '',
    'selfSigned' => '',
    'subject' => '',
    'to' => '',
    'valid' => ''
  ]),
  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}}/api/certificates', [
  'body' => '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'autoRenew' => '',
  'ca' => '',
  'caRef' => '',
  'chain' => '',
  'domain' => '',
  'from' => '',
  'id' => '',
  'privateKey' => '',
  'selfSigned' => '',
  'subject' => '',
  'to' => '',
  'valid' => ''
]));

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

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

append(json_encode([
  'autoRenew' => '',
  'ca' => '',
  'caRef' => '',
  'chain' => '',
  'domain' => '',
  'from' => '',
  'id' => '',
  'privateKey' => '',
  'selfSigned' => '',
  'subject' => '',
  'to' => '',
  'valid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/certificates');
$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}}/api/certificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/certificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}'

import http.client

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

payload = "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/api/certificates"

payload = {
    "autoRenew": "",
    "ca": "",
    "caRef": "",
    "chain": "",
    "domain": "",
    "from": "",
    "id": "",
    "privateKey": "",
    "selfSigned": "",
    "subject": "",
    "to": "",
    "valid": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/certificates"

payload <- "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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}}/api/certificates")

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  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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/api/certificates') do |req|
  req.body = "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "autoRenew": "",
        "ca": "",
        "caRef": "",
        "chain": "",
        "domain": "",
        "from": "",
        "id": "",
        "privateKey": "",
        "selfSigned": "",
        "subject": "",
        "to": "",
        "valid": ""
    });

    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}}/api/certificates \
  --header 'content-type: application/json' \
  --data '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}'

echo '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}' |  \
  http POST {{baseUrl}}/api/certificates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "autoRenew": "",\n  "ca": "",\n  "caRef": "",\n  "chain": "",\n  "domain": "",\n  "from": "",\n  "id": "",\n  "privateKey": "",\n  "selfSigned": "",\n  "subject": "",\n  "to": "",\n  "valid": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/certificates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
] as [String : Any]

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

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

{
  "autoRenew": "a string value",
  "ca": "a string value",
  "caRef": "a string value",
  "chain": "a string value",
  "domain": "a string value",
  "from": "a string value",
  "id": "a string value",
  "privateKey": "a string value",
  "selfSigned": "a string value",
  "subject": "a string value",
  "to": "a string value",
  "valid": "a string value"
}

DELETE Delete one certificate by id

{{baseUrl}}/api/certificates/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/certificates/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/certificates/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/certificates/: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/api/certificates/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/certificates/: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}}/api/certificates/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/certificates/:id'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/certificates/: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/api/certificates/: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}}/api/certificates/: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}}/api/certificates/: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}}/api/certificates/:id'};

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

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

const url = '{{baseUrl}}/api/certificates/: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}}/api/certificates/: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}}/api/certificates/:id" in

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

 "{{baseUrl}}/api/certificates/: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}}/api/certificates/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/certificates/:id');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/certificates/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/certificates/:id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/api/certificates/:id")

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

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

import requests

url = "{{baseUrl}}/api/certificates/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/certificates/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/certificates/: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/api/certificates/: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}}/api/certificates/: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}}/api/certificates/:id

http DELETE {{baseUrl}}/api/certificates/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/certificates/:id

import Foundation

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get all certificates

{{baseUrl}}/api/certificates

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/certificates")

require "http/client"

url = "{{baseUrl}}/api/certificates"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/certificates"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/certificates")
  .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}}/api/certificates');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/api/certificates');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/certificates' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/certificates' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/certificates")

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

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

import requests

url = "{{baseUrl}}/api/certificates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/certificates"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/certificates")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/api/certificates

http GET {{baseUrl}}/api/certificates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/certificates

import Foundation

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

[
  {
    "autoRenew": "a string value",
    "ca": "a string value",
    "caRef": "a string value",
    "chain": "a string value",
    "domain": "a string value",
    "from": "a string value",
    "id": "a string value",
    "privateKey": "a string value",
    "selfSigned": "a string value",
    "subject": "a string value",
    "to": "a string value",
    "valid": "a string value"
  }
]

GET Get one certificate by id

{{baseUrl}}/api/certificates/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/certificates/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/certificates/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/certificates/: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/api/certificates/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/certificates/: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}}/api/certificates/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/certificates/:id'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/certificates/:id")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/api/certificates/: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}}/api/certificates/: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}}/api/certificates/:id" in

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

 "{{baseUrl}}/api/certificates/: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}}/api/certificates/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/certificates/:id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/certificates/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/certificates/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/certificates/:id")

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

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

import requests

url = "{{baseUrl}}/api/certificates/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/certificates/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/certificates/: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/api/certificates/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/certificates/: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}}/api/certificates/:id

http GET {{baseUrl}}/api/certificates/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/certificates/:id

import Foundation

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "autoRenew": "a string value",
  "ca": "a string value",
  "caRef": "a string value",
  "chain": "a string value",
  "domain": "a string value",
  "from": "a string value",
  "id": "a string value",
  "privateKey": "a string value",
  "selfSigned": "a string value",
  "subject": "a string value",
  "to": "a string value",
  "valid": "a string value"
}

PUT Update one certificate by id (PUT)

{{baseUrl}}/api/certificates/:id

QUERY PARAMS

BODY json

{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/certificates/: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  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/certificates/:id" {:content-type :json
                                                                :form-params {:autoRenew ""
                                                                              :ca ""
                                                                              :caRef ""
                                                                              :chain ""
                                                                              :domain ""
                                                                              :from ""
                                                                              :id ""
                                                                              :privateKey ""
                                                                              :selfSigned ""
                                                                              :subject ""
                                                                              :to ""
                                                                              :valid ""}})

require "http/client"

url = "{{baseUrl}}/api/certificates/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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}}/api/certificates/:id"),
    Content = new StringContent("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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}}/api/certificates/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/certificates/:id"

	payload := strings.NewReader("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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/api/certificates/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 189

{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/certificates/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/certificates/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/certificates/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/certificates/:id")
  .header("content-type", "application/json")
  .body("{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  autoRenew: '',
  ca: '',
  caRef: '',
  chain: '',
  domain: '',
  from: '',
  id: '',
  privateKey: '',
  selfSigned: '',
  subject: '',
  to: '',
  valid: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/certificates/:id',
  headers: {'content-type': 'application/json'},
  data: {
    autoRenew: '',
    ca: '',
    caRef: '',
    chain: '',
    domain: '',
    from: '',
    id: '',
    privateKey: '',
    selfSigned: '',
    subject: '',
    to: '',
    valid: ''
  }
};

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

const url = '{{baseUrl}}/api/certificates/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"autoRenew":"","ca":"","caRef":"","chain":"","domain":"","from":"","id":"","privateKey":"","selfSigned":"","subject":"","to":"","valid":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/certificates/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "autoRenew": "",\n  "ca": "",\n  "caRef": "",\n  "chain": "",\n  "domain": "",\n  "from": "",\n  "id": "",\n  "privateKey": "",\n  "selfSigned": "",\n  "subject": "",\n  "to": "",\n  "valid": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/certificates/: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/api/certificates/: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({
  autoRenew: '',
  ca: '',
  caRef: '',
  chain: '',
  domain: '',
  from: '',
  id: '',
  privateKey: '',
  selfSigned: '',
  subject: '',
  to: '',
  valid: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/certificates/:id',
  headers: {'content-type': 'application/json'},
  body: {
    autoRenew: '',
    ca: '',
    caRef: '',
    chain: '',
    domain: '',
    from: '',
    id: '',
    privateKey: '',
    selfSigned: '',
    subject: '',
    to: '',
    valid: ''
  },
  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}}/api/certificates/:id');

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

req.type('json');
req.send({
  autoRenew: '',
  ca: '',
  caRef: '',
  chain: '',
  domain: '',
  from: '',
  id: '',
  privateKey: '',
  selfSigned: '',
  subject: '',
  to: '',
  valid: ''
});

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}}/api/certificates/:id',
  headers: {'content-type': 'application/json'},
  data: {
    autoRenew: '',
    ca: '',
    caRef: '',
    chain: '',
    domain: '',
    from: '',
    id: '',
    privateKey: '',
    selfSigned: '',
    subject: '',
    to: '',
    valid: ''
  }
};

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

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

const url = '{{baseUrl}}/api/certificates/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"autoRenew":"","ca":"","caRef":"","chain":"","domain":"","from":"","id":"","privateKey":"","selfSigned":"","subject":"","to":"","valid":""}'
};

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 = @{ @"autoRenew": @"",
                              @"ca": @"",
                              @"caRef": @"",
                              @"chain": @"",
                              @"domain": @"",
                              @"from": @"",
                              @"id": @"",
                              @"privateKey": @"",
                              @"selfSigned": @"",
                              @"subject": @"",
                              @"to": @"",
                              @"valid": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/certificates/: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}}/api/certificates/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}" in

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

 "{{baseUrl}}/api/certificates/: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([
    'autoRenew' => '',
    'ca' => '',
    'caRef' => '',
    'chain' => '',
    'domain' => '',
    'from' => '',
    'id' => '',
    'privateKey' => '',
    'selfSigned' => '',
    'subject' => '',
    'to' => '',
    'valid' => ''
  ]),
  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}}/api/certificates/:id', [
  'body' => '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/certificates/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'autoRenew' => '',
  'ca' => '',
  'caRef' => '',
  'chain' => '',
  'domain' => '',
  'from' => '',
  'id' => '',
  'privateKey' => '',
  'selfSigned' => '',
  'subject' => '',
  'to' => '',
  'valid' => ''
]));

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

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

append(json_encode([
  'autoRenew' => '',
  'ca' => '',
  'caRef' => '',
  'chain' => '',
  'domain' => '',
  'from' => '',
  'id' => '',
  'privateKey' => '',
  'selfSigned' => '',
  'subject' => '',
  'to' => '',
  'valid' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/certificates/: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}}/api/certificates/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/certificates/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}'

import http.client

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

payload = "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/api/certificates/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/certificates/:id"

payload = {
    "autoRenew": "",
    "ca": "",
    "caRef": "",
    "chain": "",
    "domain": "",
    "from": "",
    "id": "",
    "privateKey": "",
    "selfSigned": "",
    "subject": "",
    "to": "",
    "valid": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/certificates/:id"

payload <- "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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}}/api/certificates/: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  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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/api/certificates/:id') do |req|
  req.body = "{\n  \"autoRenew\": \"\",\n  \"ca\": \"\",\n  \"caRef\": \"\",\n  \"chain\": \"\",\n  \"domain\": \"\",\n  \"from\": \"\",\n  \"id\": \"\",\n  \"privateKey\": \"\",\n  \"selfSigned\": \"\",\n  \"subject\": \"\",\n  \"to\": \"\",\n  \"valid\": \"\"\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}}/api/certificates/:id";

    let payload = json!({
        "autoRenew": "",
        "ca": "",
        "caRef": "",
        "chain": "",
        "domain": "",
        "from": "",
        "id": "",
        "privateKey": "",
        "selfSigned": "",
        "subject": "",
        "to": "",
        "valid": ""
    });

    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}}/api/certificates/:id \
  --header 'content-type: application/json' \
  --data '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}'

echo '{
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
}' |  \
  http PUT {{baseUrl}}/api/certificates/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "autoRenew": "",\n  "ca": "",\n  "caRef": "",\n  "chain": "",\n  "domain": "",\n  "from": "",\n  "id": "",\n  "privateKey": "",\n  "selfSigned": "",\n  "subject": "",\n  "to": "",\n  "valid": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/certificates/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "autoRenew": "",
  "ca": "",
  "caRef": "",
  "chain": "",
  "domain": "",
  "from": "",
  "id": "",
  "privateKey": "",
  "selfSigned": "",
  "subject": "",
  "to": "",
  "valid": ""
] as [String : Any]

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

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

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "autoRenew": "a string value",
  "ca": "a string value",
  "caRef": "a string value",
  "chain": "a string value",
  "domain": "a string value",
  "from": "a string value",
  "id": "a string value",
  "privateKey": "a string value",
  "selfSigned": "a string value",
  "subject": "a string value",
  "to": "a string value",
  "valid": "a string value"
}

PATCH Update one certificate by id

{{baseUrl}}/api/certificates/:id

QUERY PARAMS

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/certificates/: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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/api/certificates/:id" {:content-type :json
                                                                  :form-params [{:op ""
                                                                                 :path ""
                                                                                 :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/certificates/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/certificates/:id"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/certificates/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/certificates/:id"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

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

}

PATCH /baseUrl/api/certificates/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/certificates/:id")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/certificates/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/certificates/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/api/certificates/:id")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/api/certificates/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/certificates/:id',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

const url = '{{baseUrl}}/api/certificates/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/certificates/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/certificates/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/certificates/: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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/certificates/:id',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/certificates/:id');

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

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/certificates/:id',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

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

const url = '{{baseUrl}}/api/certificates/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

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

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

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

 "{{baseUrl}}/api/certificates/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/certificates/:id', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/certificates/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

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

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

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/certificates/:id');
$request->setRequestMethod('PATCH');
$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}}/api/certificates/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/certificates/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

conn.request("PATCH", "/baseUrl/api/certificates/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/certificates/:id"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/certificates/:id"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/certificates/:id")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/certificates/:id') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

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

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

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/certificates/:id \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/certificates/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/certificates/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

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

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

{
  "autoRenew": "a string value",
  "ca": "a string value",
  "caRef": "a string value",
  "chain": "a string value",
  "domain": "a string value",
  "from": "a string value",
  "id": "a string value",
  "privateKey": "a string value",
  "selfSigned": "a string value",
  "subject": "a string value",
  "to": "a string value",
  "valid": "a string value"
}

GET Get the full configuration of Otoroshi

{{baseUrl}}/api/globalconfig

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/globalconfig")

require "http/client"

url = "{{baseUrl}}/api/globalconfig"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/api/globalconfig"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/globalconfig")
  .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}}/api/globalconfig');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/api/globalconfig');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/globalconfig' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/globalconfig' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/globalconfig")

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

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

import requests

url = "{{baseUrl}}/api/globalconfig"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/globalconfig"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/globalconfig")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/api/globalconfig

http GET {{baseUrl}}/api/globalconfig

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/globalconfig

import Foundation

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

{
  "alertsEmails": [
    "admin@otoroshi.io"
  ],
  "apiReadOnly": true,
  "autoLinkToDefaultGroup": true,
  "backofficeAuth0Config": {
    "callbackUrl": "a string value",
    "clientId": "a string value",
    "clientSecret": "a string value",
    "domain": "a string value"
  },
  "cleverSettings": {
    "consumerKey": "a string value",
    "consumerSecret": "a string value",
    "orgaId": "a string value",
    "secret": "a string value",
    "token": "a string value"
  },
  "elasticReadsConfig": {
    "clusterUri": "a string value",
    "headers": {
      "key": "value"
    },
    "index": "a string value",
    "password": "a string value",
    "type": "a string value",
    "user": "a string value"
  },
  "endlessIpAddresses": [
    "192.192.192.192"
  ],
  "limitConcurrentRequests": true,
  "lines": [
    "a string value"
  ],
  "mailerSettings": {
    "apiKey": "a string value",
    "apiKeyPrivate": "a string value",
    "apiKeyPublic": "a string value",
    "domain": "a string value",
    "eu": true,
    "header": {
      "key": "value"
    },
    "type": "a string value",
    "url": "a string value"
  },
  "maxConcurrentRequests": 123,
  "maxHttp10ResponseSize": 123,
  "maxLogsSize": 123123,
  "middleFingers": true,
  "perIpThrottlingQuota": 123,
  "privateAppsAuth0Config": {
    "callbackUrl": "a string value",
    "clientId": "a string value",
    "clientSecret": "a string value",
    "domain": "a string value"
  },
  "streamEntityOnly": true,
  "throttlingQuota": 123,
  "u2fLoginOnly": true,
  "useCircuitBreakers": true
}

PATCH Update the global configuration with a diff

{{baseUrl}}/api/globalconfig

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/globalconfig");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/api/globalconfig" {:content-type :json
                                                              :form-params [{:op ""
                                                                             :path ""
                                                                             :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/globalconfig"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/globalconfig"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/globalconfig");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/globalconfig"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

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

}

PATCH /baseUrl/api/globalconfig HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/globalconfig")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/globalconfig"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/globalconfig")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/api/globalconfig")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

xhr.open('PATCH', '{{baseUrl}}/api/globalconfig');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/globalconfig',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

const url = '{{baseUrl}}/api/globalconfig';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/globalconfig',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/globalconfig")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/globalconfig',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/globalconfig',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/globalconfig');

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

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/globalconfig',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

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

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

const url = '{{baseUrl}}/api/globalconfig';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

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

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

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

 "{{baseUrl}}/api/globalconfig",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/globalconfig', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/globalconfig');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

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

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

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/globalconfig');
$request->setRequestMethod('PATCH');
$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}}/api/globalconfig' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/globalconfig' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

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

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

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

conn.request("PATCH", "/baseUrl/api/globalconfig", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/globalconfig"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/globalconfig"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/globalconfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/globalconfig') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/globalconfig";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/globalconfig \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/globalconfig \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/globalconfig

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/globalconfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "alertsEmails": [
    "admin@otoroshi.io"
  ],
  "apiReadOnly": true,
  "autoLinkToDefaultGroup": true,
  "backofficeAuth0Config": {
    "callbackUrl": "a string value",
    "clientId": "a string value",
    "clientSecret": "a string value",
    "domain": "a string value"
  },
  "cleverSettings": {
    "consumerKey": "a string value",
    "consumerSecret": "a string value",
    "orgaId": "a string value",
    "secret": "a string value",
    "token": "a string value"
  },
  "elasticReadsConfig": {
    "clusterUri": "a string value",
    "headers": {
      "key": "value"
    },
    "index": "a string value",
    "password": "a string value",
    "type": "a string value",
    "user": "a string value"
  },
  "endlessIpAddresses": [
    "192.192.192.192"
  ],
  "limitConcurrentRequests": true,
  "lines": [
    "a string value"
  ],
  "mailerSettings": {
    "apiKey": "a string value",
    "apiKeyPrivate": "a string value",
    "apiKeyPublic": "a string value",
    "domain": "a string value",
    "eu": true,
    "header": {
      "key": "value"
    },
    "type": "a string value",
    "url": "a string value"
  },
  "maxConcurrentRequests": 123,
  "maxHttp10ResponseSize": 123,
  "maxLogsSize": 123123,
  "middleFingers": true,
  "perIpThrottlingQuota": 123,
  "privateAppsAuth0Config": {
    "callbackUrl": "a string value",
    "clientId": "a string value",
    "clientSecret": "a string value",
    "domain": "a string value"
  },
  "streamEntityOnly": true,
  "throttlingQuota": 123,
  "u2fLoginOnly": true,
  "useCircuitBreakers": true
}

PUT Update the global configuration

{{baseUrl}}/api/globalconfig

BODY json

{
  "alertsEmails": [],
  "alertsWebhooks": [
    {
      "headers": {},
      "url": ""
    }
  ],
  "analyticsWebhooks": [
    {}
  ],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": {
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  },
  "cleverSettings": {
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  },
  "elasticReadsConfig": {
    "clusterUri": "",
    "headers": {},
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  },
  "elasticWritesConfigs": [
    {}
  ],
  "endlessIpAddresses": [],
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": {
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": {},
    "type": "",
    "url": ""
  },
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": {},
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/globalconfig");

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  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/globalconfig" {:content-type :json
                                                            :form-params {:alertsEmails []
                                                                          :alertsWebhooks [{:headers {}
                                                                                            :url ""}]
                                                                          :analyticsWebhooks [{}]
                                                                          :apiReadOnly false
                                                                          :autoLinkToDefaultGroup false
                                                                          :backofficeAuth0Config {:callbackUrl ""
                                                                                                  :clientId ""
                                                                                                  :clientSecret ""
                                                                                                  :domain ""}
                                                                          :cleverSettings {:consumerKey ""
                                                                                           :consumerSecret ""
                                                                                           :orgaId ""
                                                                                           :secret ""
                                                                                           :token ""}
                                                                          :elasticReadsConfig {:clusterUri ""
                                                                                               :headers {}
                                                                                               :index ""
                                                                                               :password ""
                                                                                               :type ""
                                                                                               :user ""}
                                                                          :elasticWritesConfigs [{}]
                                                                          :endlessIpAddresses []
                                                                          :ipFiltering {:blacklist []
                                                                                        :whitelist []}
                                                                          :limitConcurrentRequests false
                                                                          :lines []
                                                                          :mailerSettings {:apiKey ""
                                                                                           :apiKeyPrivate ""
                                                                                           :apiKeyPublic ""
                                                                                           :domain ""
                                                                                           :eu false
                                                                                           :header {}
                                                                                           :type ""
                                                                                           :url ""}
                                                                          :maxConcurrentRequests 0
                                                                          :maxHttp10ResponseSize 0
                                                                          :maxLogsSize 0
                                                                          :middleFingers false
                                                                          :perIpThrottlingQuota 0
                                                                          :privateAppsAuth0Config {}
                                                                          :streamEntityOnly false
                                                                          :throttlingQuota 0
                                                                          :u2fLoginOnly false
                                                                          :useCircuitBreakers false}})

require "http/client"

url = "{{baseUrl}}/api/globalconfig"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\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}}/api/globalconfig"),
    Content = new StringContent("{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/globalconfig");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/globalconfig"

	payload := strings.NewReader("{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\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/api/globalconfig HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1219

{
  "alertsEmails": [],
  "alertsWebhooks": [
    {
      "headers": {},
      "url": ""
    }
  ],
  "analyticsWebhooks": [
    {}
  ],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": {
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  },
  "cleverSettings": {
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  },
  "elasticReadsConfig": {
    "clusterUri": "",
    "headers": {},
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  },
  "elasticWritesConfigs": [
    {}
  ],
  "endlessIpAddresses": [],
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": {
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": {},
    "type": "",
    "url": ""
  },
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": {},
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/globalconfig")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/globalconfig"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/globalconfig")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/globalconfig")
  .header("content-type", "application/json")
  .body("{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}")
  .asString();

const data = JSON.stringify({
  alertsEmails: [],
  alertsWebhooks: [
    {
      headers: {},
      url: ''
    }
  ],
  analyticsWebhooks: [
    {}
  ],
  apiReadOnly: false,
  autoLinkToDefaultGroup: false,
  backofficeAuth0Config: {
    callbackUrl: '',
    clientId: '',
    clientSecret: '',
    domain: ''
  },
  cleverSettings: {
    consumerKey: '',
    consumerSecret: '',
    orgaId: '',
    secret: '',
    token: ''
  },
  elasticReadsConfig: {
    clusterUri: '',
    headers: {},
    index: '',
    password: '',
    type: '',
    user: ''
  },
  elasticWritesConfigs: [
    {}
  ],
  endlessIpAddresses: [],
  ipFiltering: {
    blacklist: [],
    whitelist: []
  },
  limitConcurrentRequests: false,
  lines: [],
  mailerSettings: {
    apiKey: '',
    apiKeyPrivate: '',
    apiKeyPublic: '',
    domain: '',
    eu: false,
    header: {},
    type: '',
    url: ''
  },
  maxConcurrentRequests: 0,
  maxHttp10ResponseSize: 0,
  maxLogsSize: 0,
  middleFingers: false,
  perIpThrottlingQuota: 0,
  privateAppsAuth0Config: {},
  streamEntityOnly: false,
  throttlingQuota: 0,
  u2fLoginOnly: false,
  useCircuitBreakers: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/globalconfig');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/globalconfig',
  headers: {'content-type': 'application/json'},
  data: {
    alertsEmails: [],
    alertsWebhooks: [{headers: {}, url: ''}],
    analyticsWebhooks: [{}],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
    cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
    elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
    elasticWritesConfigs: [{}],
    endlessIpAddresses: [],
    ipFiltering: {blacklist: [], whitelist: []},
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/globalconfig';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alertsEmails":[],"alertsWebhooks":[{"headers":{},"url":""}],"analyticsWebhooks":[{}],"apiReadOnly":false,"autoLinkToDefaultGroup":false,"backofficeAuth0Config":{"callbackUrl":"","clientId":"","clientSecret":"","domain":""},"cleverSettings":{"consumerKey":"","consumerSecret":"","orgaId":"","secret":"","token":""},"elasticReadsConfig":{"clusterUri":"","headers":{},"index":"","password":"","type":"","user":""},"elasticWritesConfigs":[{}],"endlessIpAddresses":[],"ipFiltering":{"blacklist":[],"whitelist":[]},"limitConcurrentRequests":false,"lines":[],"mailerSettings":{"apiKey":"","apiKeyPrivate":"","apiKeyPublic":"","domain":"","eu":false,"header":{},"type":"","url":""},"maxConcurrentRequests":0,"maxHttp10ResponseSize":0,"maxLogsSize":0,"middleFingers":false,"perIpThrottlingQuota":0,"privateAppsAuth0Config":{},"streamEntityOnly":false,"throttlingQuota":0,"u2fLoginOnly":false,"useCircuitBreakers":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/globalconfig',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alertsEmails": [],\n  "alertsWebhooks": [\n    {\n      "headers": {},\n      "url": ""\n    }\n  ],\n  "analyticsWebhooks": [\n    {}\n  ],\n  "apiReadOnly": false,\n  "autoLinkToDefaultGroup": false,\n  "backofficeAuth0Config": {\n    "callbackUrl": "",\n    "clientId": "",\n    "clientSecret": "",\n    "domain": ""\n  },\n  "cleverSettings": {\n    "consumerKey": "",\n    "consumerSecret": "",\n    "orgaId": "",\n    "secret": "",\n    "token": ""\n  },\n  "elasticReadsConfig": {\n    "clusterUri": "",\n    "headers": {},\n    "index": "",\n    "password": "",\n    "type": "",\n    "user": ""\n  },\n  "elasticWritesConfigs": [\n    {}\n  ],\n  "endlessIpAddresses": [],\n  "ipFiltering": {\n    "blacklist": [],\n    "whitelist": []\n  },\n  "limitConcurrentRequests": false,\n  "lines": [],\n  "mailerSettings": {\n    "apiKey": "",\n    "apiKeyPrivate": "",\n    "apiKeyPublic": "",\n    "domain": "",\n    "eu": false,\n    "header": {},\n    "type": "",\n    "url": ""\n  },\n  "maxConcurrentRequests": 0,\n  "maxHttp10ResponseSize": 0,\n  "maxLogsSize": 0,\n  "middleFingers": false,\n  "perIpThrottlingQuota": 0,\n  "privateAppsAuth0Config": {},\n  "streamEntityOnly": false,\n  "throttlingQuota": 0,\n  "u2fLoginOnly": false,\n  "useCircuitBreakers": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/globalconfig")
  .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/api/globalconfig',
  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({
  alertsEmails: [],
  alertsWebhooks: [{headers: {}, url: ''}],
  analyticsWebhooks: [{}],
  apiReadOnly: false,
  autoLinkToDefaultGroup: false,
  backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
  cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
  elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
  elasticWritesConfigs: [{}],
  endlessIpAddresses: [],
  ipFiltering: {blacklist: [], whitelist: []},
  limitConcurrentRequests: false,
  lines: [],
  mailerSettings: {
    apiKey: '',
    apiKeyPrivate: '',
    apiKeyPublic: '',
    domain: '',
    eu: false,
    header: {},
    type: '',
    url: ''
  },
  maxConcurrentRequests: 0,
  maxHttp10ResponseSize: 0,
  maxLogsSize: 0,
  middleFingers: false,
  perIpThrottlingQuota: 0,
  privateAppsAuth0Config: {},
  streamEntityOnly: false,
  throttlingQuota: 0,
  u2fLoginOnly: false,
  useCircuitBreakers: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/globalconfig',
  headers: {'content-type': 'application/json'},
  body: {
    alertsEmails: [],
    alertsWebhooks: [{headers: {}, url: ''}],
    analyticsWebhooks: [{}],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
    cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
    elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
    elasticWritesConfigs: [{}],
    endlessIpAddresses: [],
    ipFiltering: {blacklist: [], whitelist: []},
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/globalconfig');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alertsEmails: [],
  alertsWebhooks: [
    {
      headers: {},
      url: ''
    }
  ],
  analyticsWebhooks: [
    {}
  ],
  apiReadOnly: false,
  autoLinkToDefaultGroup: false,
  backofficeAuth0Config: {
    callbackUrl: '',
    clientId: '',
    clientSecret: '',
    domain: ''
  },
  cleverSettings: {
    consumerKey: '',
    consumerSecret: '',
    orgaId: '',
    secret: '',
    token: ''
  },
  elasticReadsConfig: {
    clusterUri: '',
    headers: {},
    index: '',
    password: '',
    type: '',
    user: ''
  },
  elasticWritesConfigs: [
    {}
  ],
  endlessIpAddresses: [],
  ipFiltering: {
    blacklist: [],
    whitelist: []
  },
  limitConcurrentRequests: false,
  lines: [],
  mailerSettings: {
    apiKey: '',
    apiKeyPrivate: '',
    apiKeyPublic: '',
    domain: '',
    eu: false,
    header: {},
    type: '',
    url: ''
  },
  maxConcurrentRequests: 0,
  maxHttp10ResponseSize: 0,
  maxLogsSize: 0,
  middleFingers: false,
  perIpThrottlingQuota: 0,
  privateAppsAuth0Config: {},
  streamEntityOnly: false,
  throttlingQuota: 0,
  u2fLoginOnly: false,
  useCircuitBreakers: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/globalconfig',
  headers: {'content-type': 'application/json'},
  data: {
    alertsEmails: [],
    alertsWebhooks: [{headers: {}, url: ''}],
    analyticsWebhooks: [{}],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
    cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
    elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
    elasticWritesConfigs: [{}],
    endlessIpAddresses: [],
    ipFiltering: {blacklist: [], whitelist: []},
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/globalconfig';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alertsEmails":[],"alertsWebhooks":[{"headers":{},"url":""}],"analyticsWebhooks":[{}],"apiReadOnly":false,"autoLinkToDefaultGroup":false,"backofficeAuth0Config":{"callbackUrl":"","clientId":"","clientSecret":"","domain":""},"cleverSettings":{"consumerKey":"","consumerSecret":"","orgaId":"","secret":"","token":""},"elasticReadsConfig":{"clusterUri":"","headers":{},"index":"","password":"","type":"","user":""},"elasticWritesConfigs":[{}],"endlessIpAddresses":[],"ipFiltering":{"blacklist":[],"whitelist":[]},"limitConcurrentRequests":false,"lines":[],"mailerSettings":{"apiKey":"","apiKeyPrivate":"","apiKeyPublic":"","domain":"","eu":false,"header":{},"type":"","url":""},"maxConcurrentRequests":0,"maxHttp10ResponseSize":0,"maxLogsSize":0,"middleFingers":false,"perIpThrottlingQuota":0,"privateAppsAuth0Config":{},"streamEntityOnly":false,"throttlingQuota":0,"u2fLoginOnly":false,"useCircuitBreakers":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"alertsEmails": @[  ],
                              @"alertsWebhooks": @[ @{ @"headers": @{  }, @"url": @"" } ],
                              @"analyticsWebhooks": @[ @{  } ],
                              @"apiReadOnly": @NO,
                              @"autoLinkToDefaultGroup": @NO,
                              @"backofficeAuth0Config": @{ @"callbackUrl": @"", @"clientId": @"", @"clientSecret": @"", @"domain": @"" },
                              @"cleverSettings": @{ @"consumerKey": @"", @"consumerSecret": @"", @"orgaId": @"", @"secret": @"", @"token": @"" },
                              @"elasticReadsConfig": @{ @"clusterUri": @"", @"headers": @{  }, @"index": @"", @"password": @"", @"type": @"", @"user": @"" },
                              @"elasticWritesConfigs": @[ @{  } ],
                              @"endlessIpAddresses": @[  ],
                              @"ipFiltering": @{ @"blacklist": @[  ], @"whitelist": @[  ] },
                              @"limitConcurrentRequests": @NO,
                              @"lines": @[  ],
                              @"mailerSettings": @{ @"apiKey": @"", @"apiKeyPrivate": @"", @"apiKeyPublic": @"", @"domain": @"", @"eu": @NO, @"header": @{  }, @"type": @"", @"url": @"" },
                              @"maxConcurrentRequests": @0,
                              @"maxHttp10ResponseSize": @0,
                              @"maxLogsSize": @0,
                              @"middleFingers": @NO,
                              @"perIpThrottlingQuota": @0,
                              @"privateAppsAuth0Config": @{  },
                              @"streamEntityOnly": @NO,
                              @"throttlingQuota": @0,
                              @"u2fLoginOnly": @NO,
                              @"useCircuitBreakers": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/globalconfig"]
                                                       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}}/api/globalconfig" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/globalconfig",
  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([
    'alertsEmails' => [
        
    ],
    'alertsWebhooks' => [
        [
                'headers' => [
                                
                ],
                'url' => ''
        ]
    ],
    'analyticsWebhooks' => [
        [
                
        ]
    ],
    'apiReadOnly' => null,
    'autoLinkToDefaultGroup' => null,
    'backofficeAuth0Config' => [
        'callbackUrl' => '',
        'clientId' => '',
        'clientSecret' => '',
        'domain' => ''
    ],
    'cleverSettings' => [
        'consumerKey' => '',
        'consumerSecret' => '',
        'orgaId' => '',
        'secret' => '',
        'token' => ''
    ],
    'elasticReadsConfig' => [
        'clusterUri' => '',
        'headers' => [
                
        ],
        'index' => '',
        'password' => '',
        'type' => '',
        'user' => ''
    ],
    'elasticWritesConfigs' => [
        [
                
        ]
    ],
    'endlessIpAddresses' => [
        
    ],
    'ipFiltering' => [
        'blacklist' => [
                
        ],
        'whitelist' => [
                
        ]
    ],
    'limitConcurrentRequests' => null,
    'lines' => [
        
    ],
    'mailerSettings' => [
        'apiKey' => '',
        'apiKeyPrivate' => '',
        'apiKeyPublic' => '',
        'domain' => '',
        'eu' => null,
        'header' => [
                
        ],
        'type' => '',
        'url' => ''
    ],
    'maxConcurrentRequests' => 0,
    'maxHttp10ResponseSize' => 0,
    'maxLogsSize' => 0,
    'middleFingers' => null,
    'perIpThrottlingQuota' => 0,
    'privateAppsAuth0Config' => [
        
    ],
    'streamEntityOnly' => null,
    'throttlingQuota' => 0,
    'u2fLoginOnly' => null,
    'useCircuitBreakers' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/globalconfig', [
  'body' => '{
  "alertsEmails": [],
  "alertsWebhooks": [
    {
      "headers": {},
      "url": ""
    }
  ],
  "analyticsWebhooks": [
    {}
  ],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": {
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  },
  "cleverSettings": {
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  },
  "elasticReadsConfig": {
    "clusterUri": "",
    "headers": {},
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  },
  "elasticWritesConfigs": [
    {}
  ],
  "endlessIpAddresses": [],
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": {
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": {},
    "type": "",
    "url": ""
  },
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": {},
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/globalconfig');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alertsEmails' => [
    
  ],
  'alertsWebhooks' => [
    [
        'headers' => [
                
        ],
        'url' => ''
    ]
  ],
  'analyticsWebhooks' => [
    [
        
    ]
  ],
  'apiReadOnly' => null,
  'autoLinkToDefaultGroup' => null,
  'backofficeAuth0Config' => [
    'callbackUrl' => '',
    'clientId' => '',
    'clientSecret' => '',
    'domain' => ''
  ],
  'cleverSettings' => [
    'consumerKey' => '',
    'consumerSecret' => '',
    'orgaId' => '',
    'secret' => '',
    'token' => ''
  ],
  'elasticReadsConfig' => [
    'clusterUri' => '',
    'headers' => [
        
    ],
    'index' => '',
    'password' => '',
    'type' => '',
    'user' => ''
  ],
  'elasticWritesConfigs' => [
    [
        
    ]
  ],
  'endlessIpAddresses' => [
    
  ],
  'ipFiltering' => [
    'blacklist' => [
        
    ],
    'whitelist' => [
        
    ]
  ],
  'limitConcurrentRequests' => null,
  'lines' => [
    
  ],
  'mailerSettings' => [
    'apiKey' => '',
    'apiKeyPrivate' => '',
    'apiKeyPublic' => '',
    'domain' => '',
    'eu' => null,
    'header' => [
        
    ],
    'type' => '',
    'url' => ''
  ],
  'maxConcurrentRequests' => 0,
  'maxHttp10ResponseSize' => 0,
  'maxLogsSize' => 0,
  'middleFingers' => null,
  'perIpThrottlingQuota' => 0,
  'privateAppsAuth0Config' => [
    
  ],
  'streamEntityOnly' => null,
  'throttlingQuota' => 0,
  'u2fLoginOnly' => null,
  'useCircuitBreakers' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alertsEmails' => [
    
  ],
  'alertsWebhooks' => [
    [
        'headers' => [
                
        ],
        'url' => ''
    ]
  ],
  'analyticsWebhooks' => [
    [
        
    ]
  ],
  'apiReadOnly' => null,
  'autoLinkToDefaultGroup' => null,
  'backofficeAuth0Config' => [
    'callbackUrl' => '',
    'clientId' => '',
    'clientSecret' => '',
    'domain' => ''
  ],
  'cleverSettings' => [
    'consumerKey' => '',
    'consumerSecret' => '',
    'orgaId' => '',
    'secret' => '',
    'token' => ''
  ],
  'elasticReadsConfig' => [
    'clusterUri' => '',
    'headers' => [
        
    ],
    'index' => '',
    'password' => '',
    'type' => '',
    'user' => ''
  ],
  'elasticWritesConfigs' => [
    [
        
    ]
  ],
  'endlessIpAddresses' => [
    
  ],
  'ipFiltering' => [
    'blacklist' => [
        
    ],
    'whitelist' => [
        
    ]
  ],
  'limitConcurrentRequests' => null,
  'lines' => [
    
  ],
  'mailerSettings' => [
    'apiKey' => '',
    'apiKeyPrivate' => '',
    'apiKeyPublic' => '',
    'domain' => '',
    'eu' => null,
    'header' => [
        
    ],
    'type' => '',
    'url' => ''
  ],
  'maxConcurrentRequests' => 0,
  'maxHttp10ResponseSize' => 0,
  'maxLogsSize' => 0,
  'middleFingers' => null,
  'perIpThrottlingQuota' => 0,
  'privateAppsAuth0Config' => [
    
  ],
  'streamEntityOnly' => null,
  'throttlingQuota' => 0,
  'u2fLoginOnly' => null,
  'useCircuitBreakers' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/globalconfig');
$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}}/api/globalconfig' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alertsEmails": [],
  "alertsWebhooks": [
    {
      "headers": {},
      "url": ""
    }
  ],
  "analyticsWebhooks": [
    {}
  ],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": {
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  },
  "cleverSettings": {
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  },
  "elasticReadsConfig": {
    "clusterUri": "",
    "headers": {},
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  },
  "elasticWritesConfigs": [
    {}
  ],
  "endlessIpAddresses": [],
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": {
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": {},
    "type": "",
    "url": ""
  },
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": {},
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/globalconfig' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alertsEmails": [],
  "alertsWebhooks": [
    {
      "headers": {},
      "url": ""
    }
  ],
  "analyticsWebhooks": [
    {}
  ],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": {
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  },
  "cleverSettings": {
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  },
  "elasticReadsConfig": {
    "clusterUri": "",
    "headers": {},
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  },
  "elasticWritesConfigs": [
    {}
  ],
  "endlessIpAddresses": [],
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": {
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": {},
    "type": "",
    "url": ""
  },
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": {},
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/globalconfig", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/globalconfig"

payload = {
    "alertsEmails": [],
    "alertsWebhooks": [
        {
            "headers": {},
            "url": ""
        }
    ],
    "analyticsWebhooks": [{}],
    "apiReadOnly": False,
    "autoLinkToDefaultGroup": False,
    "backofficeAuth0Config": {
        "callbackUrl": "",
        "clientId": "",
        "clientSecret": "",
        "domain": ""
    },
    "cleverSettings": {
        "consumerKey": "",
        "consumerSecret": "",
        "orgaId": "",
        "secret": "",
        "token": ""
    },
    "elasticReadsConfig": {
        "clusterUri": "",
        "headers": {},
        "index": "",
        "password": "",
        "type": "",
        "user": ""
    },
    "elasticWritesConfigs": [{}],
    "endlessIpAddresses": [],
    "ipFiltering": {
        "blacklist": [],
        "whitelist": []
    },
    "limitConcurrentRequests": False,
    "lines": [],
    "mailerSettings": {
        "apiKey": "",
        "apiKeyPrivate": "",
        "apiKeyPublic": "",
        "domain": "",
        "eu": False,
        "header": {},
        "type": "",
        "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": False,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": False,
    "throttlingQuota": 0,
    "u2fLoginOnly": False,
    "useCircuitBreakers": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/globalconfig"

payload <- "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\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}}/api/globalconfig")

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  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/api/globalconfig') do |req|
  req.body = "{\n  \"alertsEmails\": [],\n  \"alertsWebhooks\": [\n    {\n      \"headers\": {},\n      \"url\": \"\"\n    }\n  ],\n  \"analyticsWebhooks\": [\n    {}\n  ],\n  \"apiReadOnly\": false,\n  \"autoLinkToDefaultGroup\": false,\n  \"backofficeAuth0Config\": {\n    \"callbackUrl\": \"\",\n    \"clientId\": \"\",\n    \"clientSecret\": \"\",\n    \"domain\": \"\"\n  },\n  \"cleverSettings\": {\n    \"consumerKey\": \"\",\n    \"consumerSecret\": \"\",\n    \"orgaId\": \"\",\n    \"secret\": \"\",\n    \"token\": \"\"\n  },\n  \"elasticReadsConfig\": {\n    \"clusterUri\": \"\",\n    \"headers\": {},\n    \"index\": \"\",\n    \"password\": \"\",\n    \"type\": \"\",\n    \"user\": \"\"\n  },\n  \"elasticWritesConfigs\": [\n    {}\n  ],\n  \"endlessIpAddresses\": [],\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"limitConcurrentRequests\": false,\n  \"lines\": [],\n  \"mailerSettings\": {\n    \"apiKey\": \"\",\n    \"apiKeyPrivate\": \"\",\n    \"apiKeyPublic\": \"\",\n    \"domain\": \"\",\n    \"eu\": false,\n    \"header\": {},\n    \"type\": \"\",\n    \"url\": \"\"\n  },\n  \"maxConcurrentRequests\": 0,\n  \"maxHttp10ResponseSize\": 0,\n  \"maxLogsSize\": 0,\n  \"middleFingers\": false,\n  \"perIpThrottlingQuota\": 0,\n  \"privateAppsAuth0Config\": {},\n  \"streamEntityOnly\": false,\n  \"throttlingQuota\": 0,\n  \"u2fLoginOnly\": false,\n  \"useCircuitBreakers\": false\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}}/api/globalconfig";

    let payload = json!({
        "alertsEmails": (),
        "alertsWebhooks": (
            json!({
                "headers": json!({}),
                "url": ""
            })
        ),
        "analyticsWebhooks": (json!({})),
        "apiReadOnly": false,
        "autoLinkToDefaultGroup": false,
        "backofficeAuth0Config": json!({
            "callbackUrl": "",
            "clientId": "",
            "clientSecret": "",
            "domain": ""
        }),
        "cleverSettings": json!({
            "consumerKey": "",
            "consumerSecret": "",
            "orgaId": "",
            "secret": "",
            "token": ""
        }),
        "elasticReadsConfig": json!({
            "clusterUri": "",
            "headers": json!({}),
            "index": "",
            "password": "",
            "type": "",
            "user": ""
        }),
        "elasticWritesConfigs": (json!({})),
        "endlessIpAddresses": (),
        "ipFiltering": json!({
            "blacklist": (),
            "whitelist": ()
        }),
        "limitConcurrentRequests": false,
        "lines": (),
        "mailerSettings": json!({
            "apiKey": "",
            "apiKeyPrivate": "",
            "apiKeyPublic": "",
            "domain": "",
            "eu": false,
            "header": json!({}),
            "type": "",
            "url": ""
        }),
        "maxConcurrentRequests": 0,
        "maxHttp10ResponseSize": 0,
        "maxLogsSize": 0,
        "middleFingers": false,
        "perIpThrottlingQuota": 0,
        "privateAppsAuth0Config": json!({}),
        "streamEntityOnly": false,
        "throttlingQuota": 0,
        "u2fLoginOnly": false,
        "useCircuitBreakers": false
    });

    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}}/api/globalconfig \
  --header 'content-type: application/json' \
  --data '{
  "alertsEmails": [],
  "alertsWebhooks": [
    {
      "headers": {},
      "url": ""
    }
  ],
  "analyticsWebhooks": [
    {}
  ],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": {
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  },
  "cleverSettings": {
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  },
  "elasticReadsConfig": {
    "clusterUri": "",
    "headers": {},
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  },
  "elasticWritesConfigs": [
    {}
  ],
  "endlessIpAddresses": [],
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": {
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": {},
    "type": "",
    "url": ""
  },
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": {},
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
}'

echo '{
  "alertsEmails": [],
  "alertsWebhooks": [
    {
      "headers": {},
      "url": ""
    }
  ],
  "analyticsWebhooks": [
    {}
  ],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": {
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  },
  "cleverSettings": {
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  },
  "elasticReadsConfig": {
    "clusterUri": "",
    "headers": {},
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  },
  "elasticWritesConfigs": [
    {}
  ],
  "endlessIpAddresses": [],
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": {
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": {},
    "type": "",
    "url": ""
  },
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": {},
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
}' |  \
  http PUT {{baseUrl}}/api/globalconfig \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alertsEmails": [],\n  "alertsWebhooks": [\n    {\n      "headers": {},\n      "url": ""\n    }\n  ],\n  "analyticsWebhooks": [\n    {}\n  ],\n  "apiReadOnly": false,\n  "autoLinkToDefaultGroup": false,\n  "backofficeAuth0Config": {\n    "callbackUrl": "",\n    "clientId": "",\n    "clientSecret": "",\n    "domain": ""\n  },\n  "cleverSettings": {\n    "consumerKey": "",\n    "consumerSecret": "",\n    "orgaId": "",\n    "secret": "",\n    "token": ""\n  },\n  "elasticReadsConfig": {\n    "clusterUri": "",\n    "headers": {},\n    "index": "",\n    "password": "",\n    "type": "",\n    "user": ""\n  },\n  "elasticWritesConfigs": [\n    {}\n  ],\n  "endlessIpAddresses": [],\n  "ipFiltering": {\n    "blacklist": [],\n    "whitelist": []\n  },\n  "limitConcurrentRequests": false,\n  "lines": [],\n  "mailerSettings": {\n    "apiKey": "",\n    "apiKeyPrivate": "",\n    "apiKeyPublic": "",\n    "domain": "",\n    "eu": false,\n    "header": {},\n    "type": "",\n    "url": ""\n  },\n  "maxConcurrentRequests": 0,\n  "maxHttp10ResponseSize": 0,\n  "maxLogsSize": 0,\n  "middleFingers": false,\n  "perIpThrottlingQuota": 0,\n  "privateAppsAuth0Config": {},\n  "streamEntityOnly": false,\n  "throttlingQuota": 0,\n  "u2fLoginOnly": false,\n  "useCircuitBreakers": false\n}' \
  --output-document \
  - {{baseUrl}}/api/globalconfig

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alertsEmails": [],
  "alertsWebhooks": [
    [
      "headers": [],
      "url": ""
    ]
  ],
  "analyticsWebhooks": [[]],
  "apiReadOnly": false,
  "autoLinkToDefaultGroup": false,
  "backofficeAuth0Config": [
    "callbackUrl": "",
    "clientId": "",
    "clientSecret": "",
    "domain": ""
  ],
  "cleverSettings": [
    "consumerKey": "",
    "consumerSecret": "",
    "orgaId": "",
    "secret": "",
    "token": ""
  ],
  "elasticReadsConfig": [
    "clusterUri": "",
    "headers": [],
    "index": "",
    "password": "",
    "type": "",
    "user": ""
  ],
  "elasticWritesConfigs": [[]],
  "endlessIpAddresses": [],
  "ipFiltering": [
    "blacklist": [],
    "whitelist": []
  ],
  "limitConcurrentRequests": false,
  "lines": [],
  "mailerSettings": [
    "apiKey": "",
    "apiKeyPrivate": "",
    "apiKeyPublic": "",
    "domain": "",
    "eu": false,
    "header": [],
    "type": "",
    "url": ""
  ],
  "maxConcurrentRequests": 0,
  "maxHttp10ResponseSize": 0,
  "maxLogsSize": 0,
  "middleFingers": false,
  "perIpThrottlingQuota": 0,
  "privateAppsAuth0Config": [],
  "streamEntityOnly": false,
  "throttlingQuota": 0,
  "u2fLoginOnly": false,
  "useCircuitBreakers": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/globalconfig")! 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

{
  "alertsEmails": [
    "admin@otoroshi.io"
  ],
  "apiReadOnly": true,
  "autoLinkToDefaultGroup": true,
  "backofficeAuth0Config": {
    "callbackUrl": "a string value",
    "clientId": "a string value",
    "clientSecret": "a string value",
    "domain": "a string value"
  },
  "cleverSettings": {
    "consumerKey": "a string value",
    "consumerSecret": "a string value",
    "orgaId": "a string value",
    "secret": "a string value",
    "token": "a string value"
  },
  "elasticReadsConfig": {
    "clusterUri": "a string value",
    "headers": {
      "key": "value"
    },
    "index": "a string value",
    "password": "a string value",
    "type": "a string value",
    "user": "a string value"
  },
  "endlessIpAddresses": [
    "192.192.192.192"
  ],
  "limitConcurrentRequests": true,
  "lines": [
    "a string value"
  ],
  "mailerSettings": {
    "apiKey": "a string value",
    "apiKeyPrivate": "a string value",
    "apiKeyPublic": "a string value",
    "domain": "a string value",
    "eu": true,
    "header": {
      "key": "value"
    },
    "type": "a string value",
    "url": "a string value"
  },
  "maxConcurrentRequests": 123,
  "maxHttp10ResponseSize": 123,
  "maxLogsSize": 123123,
  "middleFingers": true,
  "perIpThrottlingQuota": 123,
  "privateAppsAuth0Config": {
    "callbackUrl": "a string value",
    "clientId": "a string value",
    "clientSecret": "a string value",
    "domain": "a string value"
  },
  "streamEntityOnly": true,
  "throttlingQuota": 123,
  "u2fLoginOnly": true,
  "useCircuitBreakers": true
}

POST Create a new data exporter config

{{baseUrl}}/api/data-exporter-configs

BODY json

{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs");

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  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/data-exporter-configs" {:content-type :json
                                                                      :form-params {:bufferSize 0
                                                                                    :config ""
                                                                                    :desc ""
                                                                                    :enabled ""
                                                                                    :filtering {:exclude [{}]
                                                                                                :include [{}]}
                                                                                    :groupDuration 0
                                                                                    :groupSize 0
                                                                                    :id ""
                                                                                    :jsonWorkers 0
                                                                                    :location {:teams [{}]
                                                                                               :tenant ""}
                                                                                    :metadata {}
                                                                                    :name ""
                                                                                    :projection {}
                                                                                    :sendWorkers 0
                                                                                    :typ ""}})

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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}}/api/data-exporter-configs"),
    Content = new StringContent("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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}}/api/data-exporter-configs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs"

	payload := strings.NewReader("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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/api/data-exporter-configs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 381

{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/data-exporter-configs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/data-exporter-configs")
  .header("content-type", "application/json")
  .body("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  bufferSize: 0,
  config: '',
  desc: '',
  enabled: '',
  filtering: {
    exclude: [
      {}
    ],
    include: [
      {}
    ]
  },
  groupDuration: 0,
  groupSize: 0,
  id: '',
  jsonWorkers: 0,
  location: {
    teams: [
      {}
    ],
    tenant: ''
  },
  metadata: {},
  name: '',
  projection: {},
  sendWorkers: 0,
  typ: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/data-exporter-configs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/data-exporter-configs',
  headers: {'content-type': 'application/json'},
  data: {
    bufferSize: 0,
    config: '',
    desc: '',
    enabled: '',
    filtering: {exclude: [{}], include: [{}]},
    groupDuration: 0,
    groupSize: 0,
    id: '',
    jsonWorkers: 0,
    location: {teams: [{}], tenant: ''},
    metadata: {},
    name: '',
    projection: {},
    sendWorkers: 0,
    typ: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"bufferSize":0,"config":"","desc":"","enabled":"","filtering":{"exclude":[{}],"include":[{}]},"groupDuration":0,"groupSize":0,"id":"","jsonWorkers":0,"location":{"teams":[{}],"tenant":""},"metadata":{},"name":"","projection":{},"sendWorkers":0,"typ":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/data-exporter-configs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bufferSize": 0,\n  "config": "",\n  "desc": "",\n  "enabled": "",\n  "filtering": {\n    "exclude": [\n      {}\n    ],\n    "include": [\n      {}\n    ]\n  },\n  "groupDuration": 0,\n  "groupSize": 0,\n  "id": "",\n  "jsonWorkers": 0,\n  "location": {\n    "teams": [\n      {}\n    ],\n    "tenant": ""\n  },\n  "metadata": {},\n  "name": "",\n  "projection": {},\n  "sendWorkers": 0,\n  "typ": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs")
  .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/api/data-exporter-configs',
  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({
  bufferSize: 0,
  config: '',
  desc: '',
  enabled: '',
  filtering: {exclude: [{}], include: [{}]},
  groupDuration: 0,
  groupSize: 0,
  id: '',
  jsonWorkers: 0,
  location: {teams: [{}], tenant: ''},
  metadata: {},
  name: '',
  projection: {},
  sendWorkers: 0,
  typ: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/data-exporter-configs',
  headers: {'content-type': 'application/json'},
  body: {
    bufferSize: 0,
    config: '',
    desc: '',
    enabled: '',
    filtering: {exclude: [{}], include: [{}]},
    groupDuration: 0,
    groupSize: 0,
    id: '',
    jsonWorkers: 0,
    location: {teams: [{}], tenant: ''},
    metadata: {},
    name: '',
    projection: {},
    sendWorkers: 0,
    typ: ''
  },
  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}}/api/data-exporter-configs');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  bufferSize: 0,
  config: '',
  desc: '',
  enabled: '',
  filtering: {
    exclude: [
      {}
    ],
    include: [
      {}
    ]
  },
  groupDuration: 0,
  groupSize: 0,
  id: '',
  jsonWorkers: 0,
  location: {
    teams: [
      {}
    ],
    tenant: ''
  },
  metadata: {},
  name: '',
  projection: {},
  sendWorkers: 0,
  typ: ''
});

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}}/api/data-exporter-configs',
  headers: {'content-type': 'application/json'},
  data: {
    bufferSize: 0,
    config: '',
    desc: '',
    enabled: '',
    filtering: {exclude: [{}], include: [{}]},
    groupDuration: 0,
    groupSize: 0,
    id: '',
    jsonWorkers: 0,
    location: {teams: [{}], tenant: ''},
    metadata: {},
    name: '',
    projection: {},
    sendWorkers: 0,
    typ: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"bufferSize":0,"config":"","desc":"","enabled":"","filtering":{"exclude":[{}],"include":[{}]},"groupDuration":0,"groupSize":0,"id":"","jsonWorkers":0,"location":{"teams":[{}],"tenant":""},"metadata":{},"name":"","projection":{},"sendWorkers":0,"typ":""}'
};

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 = @{ @"bufferSize": @0,
                              @"config": @"",
                              @"desc": @"",
                              @"enabled": @"",
                              @"filtering": @{ @"exclude": @[ @{  } ], @"include": @[ @{  } ] },
                              @"groupDuration": @0,
                              @"groupSize": @0,
                              @"id": @"",
                              @"jsonWorkers": @0,
                              @"location": @{ @"teams": @[ @{  } ], @"tenant": @"" },
                              @"metadata": @{  },
                              @"name": @"",
                              @"projection": @{  },
                              @"sendWorkers": @0,
                              @"typ": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/data-exporter-configs"]
                                                       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}}/api/data-exporter-configs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs",
  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([
    'bufferSize' => 0,
    'config' => '',
    'desc' => '',
    'enabled' => '',
    'filtering' => [
        'exclude' => [
                [
                                
                ]
        ],
        'include' => [
                [
                                
                ]
        ]
    ],
    'groupDuration' => 0,
    'groupSize' => 0,
    'id' => '',
    'jsonWorkers' => 0,
    'location' => [
        'teams' => [
                [
                                
                ]
        ],
        'tenant' => ''
    ],
    'metadata' => [
        
    ],
    'name' => '',
    'projection' => [
        
    ],
    'sendWorkers' => 0,
    'typ' => ''
  ]),
  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}}/api/data-exporter-configs', [
  'body' => '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bufferSize' => 0,
  'config' => '',
  'desc' => '',
  'enabled' => '',
  'filtering' => [
    'exclude' => [
        [
                
        ]
    ],
    'include' => [
        [
                
        ]
    ]
  ],
  'groupDuration' => 0,
  'groupSize' => 0,
  'id' => '',
  'jsonWorkers' => 0,
  'location' => [
    'teams' => [
        [
                
        ]
    ],
    'tenant' => ''
  ],
  'metadata' => [
    
  ],
  'name' => '',
  'projection' => [
    
  ],
  'sendWorkers' => 0,
  'typ' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'bufferSize' => 0,
  'config' => '',
  'desc' => '',
  'enabled' => '',
  'filtering' => [
    'exclude' => [
        [
                
        ]
    ],
    'include' => [
        [
                
        ]
    ]
  ],
  'groupDuration' => 0,
  'groupSize' => 0,
  'id' => '',
  'jsonWorkers' => 0,
  'location' => [
    'teams' => [
        [
                
        ]
    ],
    'tenant' => ''
  ],
  'metadata' => [
    
  ],
  'name' => '',
  'projection' => [
    
  ],
  'sendWorkers' => 0,
  'typ' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/data-exporter-configs');
$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}}/api/data-exporter-configs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/data-exporter-configs", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs"

payload = {
    "bufferSize": 0,
    "config": "",
    "desc": "",
    "enabled": "",
    "filtering": {
        "exclude": [{}],
        "include": [{}]
    },
    "groupDuration": 0,
    "groupSize": 0,
    "id": "",
    "jsonWorkers": 0,
    "location": {
        "teams": [{}],
        "tenant": ""
    },
    "metadata": {},
    "name": "",
    "projection": {},
    "sendWorkers": 0,
    "typ": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs"

payload <- "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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}}/api/data-exporter-configs")

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  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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/api/data-exporter-configs') do |req|
  req.body = "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs";

    let payload = json!({
        "bufferSize": 0,
        "config": "",
        "desc": "",
        "enabled": "",
        "filtering": json!({
            "exclude": (json!({})),
            "include": (json!({}))
        }),
        "groupDuration": 0,
        "groupSize": 0,
        "id": "",
        "jsonWorkers": 0,
        "location": json!({
            "teams": (json!({})),
            "tenant": ""
        }),
        "metadata": json!({}),
        "name": "",
        "projection": json!({}),
        "sendWorkers": 0,
        "typ": ""
    });

    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}}/api/data-exporter-configs \
  --header 'content-type: application/json' \
  --data '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}'

echo '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}' |  \
  http POST {{baseUrl}}/api/data-exporter-configs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "bufferSize": 0,\n  "config": "",\n  "desc": "",\n  "enabled": "",\n  "filtering": {\n    "exclude": [\n      {}\n    ],\n    "include": [\n      {}\n    ]\n  },\n  "groupDuration": 0,\n  "groupSize": 0,\n  "id": "",\n  "jsonWorkers": 0,\n  "location": {\n    "teams": [\n      {}\n    ],\n    "tenant": ""\n  },\n  "metadata": {},\n  "name": "",\n  "projection": {},\n  "sendWorkers": 0,\n  "typ": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": [
    "exclude": [[]],
    "include": [[]]
  ],
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": [
    "teams": [[]],
    "tenant": ""
  ],
  "metadata": [],
  "name": "",
  "projection": [],
  "sendWorkers": 0,
  "typ": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs")! 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

{
  "bufferSize": 123123,
  "desc": "a string value",
  "enabled": "a string value",
  "groupDuration": 123,
  "groupSize": 123123,
  "id": "a string value",
  "jsonWorkers": 123123,
  "location": {
    "tenant": "a string value"
  },
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "projection": {
    "key": "value"
  },
  "sendWorkers": 123123
}

POST Create a new data exporter configs

{{baseUrl}}/api/data-exporter-configs/_bulk

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/_bulk");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/data-exporter-configs/_bulk")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

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}}/api/data-exporter-configs/_bulk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs/_bulk");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/_bulk"

	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/api/data-exporter-configs/_bulk HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/data-exporter-configs/_bulk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/_bulk"))
    .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}}/api/data-exporter-configs/_bulk")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .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}}/api/data-exporter-configs/_bulk');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
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}}/api/data-exporter-configs/_bulk',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/_bulk',
  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}}/api/data-exporter-configs/_bulk'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/data-exporter-configs/_bulk');

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}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
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}}/api/data-exporter-configs/_bulk"]
                                                       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}}/api/data-exporter-configs/_bulk" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/_bulk",
  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}}/api/data-exporter-configs/_bulk');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/data-exporter-configs/_bulk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/_bulk"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/_bulk")

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/api/data-exporter-configs/_bulk') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/_bulk";

    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}}/api/data-exporter-configs/_bulk

http POST {{baseUrl}}/api/data-exporter-configs/_bulk

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/_bulk

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/_bulk")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "created": true,
    "id": true
  }
]

DELETE Delete a data exporter config (DELETE)

{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

QUERY PARAMS

dataExporterConfigId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

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}}/api/data-exporter-configs/:dataExporterConfigId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

	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/api/data-exporter-configs/:dataExporterConfigId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"))
    .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}}/api/data-exporter-configs/:dataExporterConfigId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .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}}/api/data-exporter-configs/:dataExporterConfigId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
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}}/api/data-exporter-configs/:dataExporterConfigId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/:dataExporterConfigId',
  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}}/api/data-exporter-configs/:dataExporterConfigId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');

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}}/api/data-exporter-configs/:dataExporterConfigId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
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}}/api/data-exporter-configs/:dataExporterConfigId"]
                                                       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}}/api/data-exporter-configs/:dataExporterConfigId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId",
  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}}/api/data-exporter-configs/:dataExporterConfigId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/data-exporter-configs/:dataExporterConfigId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")

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/api/data-exporter-configs/:dataExporterConfigId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId";

    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}}/api/data-exporter-configs/:dataExporterConfigId

http DELETE {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

DELETE Delete a data exporter config

{{baseUrl}}/api/data-exporter-configs/_bulk

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/_bulk");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/data-exporter-configs/_bulk")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

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}}/api/data-exporter-configs/_bulk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs/_bulk");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/_bulk"

	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/api/data-exporter-configs/_bulk HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/data-exporter-configs/_bulk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/_bulk"))
    .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}}/api/data-exporter-configs/_bulk")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .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}}/api/data-exporter-configs/_bulk');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
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}}/api/data-exporter-configs/_bulk',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/_bulk',
  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}}/api/data-exporter-configs/_bulk'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/data-exporter-configs/_bulk');

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}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
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}}/api/data-exporter-configs/_bulk"]
                                                       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}}/api/data-exporter-configs/_bulk" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/_bulk",
  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}}/api/data-exporter-configs/_bulk');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/data-exporter-configs/_bulk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/_bulk"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/_bulk")

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/api/data-exporter-configs/_bulk') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/_bulk";

    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}}/api/data-exporter-configs/_bulk

http DELETE {{baseUrl}}/api/data-exporter-configs/_bulk

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/_bulk

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/_bulk")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "deleted": true,
    "id": true
  }
]

GET Get a data exporter config

{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

QUERY PARAMS

dataExporterConfigId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

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}}/api/data-exporter-configs/:dataExporterConfigId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

	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/api/data-exporter-configs/:dataExporterConfigId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"))
    .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}}/api/data-exporter-configs/:dataExporterConfigId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .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}}/api/data-exporter-configs/:dataExporterConfigId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
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}}/api/data-exporter-configs/:dataExporterConfigId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/:dataExporterConfigId',
  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}}/api/data-exporter-configs/:dataExporterConfigId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');

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}}/api/data-exporter-configs/:dataExporterConfigId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
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}}/api/data-exporter-configs/:dataExporterConfigId"]
                                                       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}}/api/data-exporter-configs/:dataExporterConfigId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId",
  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}}/api/data-exporter-configs/:dataExporterConfigId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/data-exporter-configs/:dataExporterConfigId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")

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/api/data-exporter-configs/:dataExporterConfigId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId";

    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}}/api/data-exporter-configs/:dataExporterConfigId

http GET {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")! 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

{
  "bufferSize": 123123,
  "desc": "a string value",
  "enabled": "a string value",
  "groupDuration": 123,
  "groupSize": 123123,
  "id": "a string value",
  "jsonWorkers": 123123,
  "location": {
    "tenant": "a string value"
  },
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "projection": {
    "key": "value"
  },
  "sendWorkers": 123123
}

GET Get all data exporter configs (GET)

{{baseUrl}}/api/data-exporter-configs/_template

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/_template");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/data-exporter-configs/_template")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs/_template");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/_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/api/data-exporter-configs/_template HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/data-exporter-configs/_template")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/data-exporter-configs/_template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/_template")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/_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}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/_template');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs/_template');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs/_template' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/_template' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/data-exporter-configs/_template")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/_template"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/_template"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/_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/api/data-exporter-configs/_template') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/_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}}/api/data-exporter-configs/_template

http GET {{baseUrl}}/api/data-exporter-configs/_template

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/_template

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/_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

{
  "bufferSize": 123123,
  "desc": "a string value",
  "enabled": "a string value",
  "groupDuration": 123,
  "groupSize": 123123,
  "id": "a string value",
  "jsonWorkers": 123123,
  "location": {
    "tenant": "a string value"
  },
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "projection": {
    "key": "value"
  },
  "sendWorkers": 123123
}

GET Get all data exporter configs

{{baseUrl}}/api/data-exporter-configs

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/data-exporter-configs")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs"

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}}/api/data-exporter-configs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs"

	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/api/data-exporter-configs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/data-exporter-configs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs"))
    .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}}/api/data-exporter-configs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/data-exporter-configs")
  .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}}/api/data-exporter-configs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/data-exporter-configs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs';
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}}/api/data-exporter-configs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs',
  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}}/api/data-exporter-configs'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/data-exporter-configs');

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}}/api/data-exporter-configs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs';
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}}/api/data-exporter-configs"]
                                                       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}}/api/data-exporter-configs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs",
  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}}/api/data-exporter-configs');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/data-exporter-configs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs")

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/api/data-exporter-configs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs";

    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}}/api/data-exporter-configs

http GET {{baseUrl}}/api/data-exporter-configs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs")! 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

[
  {
    "bufferSize": 123123,
    "desc": "a string value",
    "enabled": "a string value",
    "groupDuration": 123,
    "groupSize": 123123,
    "id": "a string value",
    "jsonWorkers": 123123,
    "metadata": {
      "key": "value"
    },
    "name": "a string value",
    "projection": {
      "key": "value"
    },
    "sendWorkers": 123123
  }
]

PATCH Update a data exporter config with a diff

{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

QUERY PARAMS

dataExporterConfigId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId" {:content-type :json
                                                                                             :form-params [{:op ""
                                                                                                            :path ""
                                                                                                            :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/data-exporter-configs/:dataExporterConfigId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/data-exporter-configs/:dataExporterConfigId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/:dataExporterConfigId',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/data-exporter-configs/:dataExporterConfigId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$request->setRequestMethod('PATCH');
$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}}/api/data-exporter-configs/:dataExporterConfigId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/data-exporter-configs/:dataExporterConfigId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/data-exporter-configs/:dataExporterConfigId') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "bufferSize": 123123,
  "desc": "a string value",
  "enabled": "a string value",
  "groupDuration": 123,
  "groupSize": 123123,
  "id": "a string value",
  "jsonWorkers": 123123,
  "location": {
    "tenant": "a string value"
  },
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "projection": {
    "key": "value"
  },
  "sendWorkers": 123123
}

PUT Update a data exporter config

{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

QUERY PARAMS

dataExporterConfigId

BODY json

{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId");

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  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId" {:content-type :json
                                                                                           :form-params {:bufferSize 0
                                                                                                         :config ""
                                                                                                         :desc ""
                                                                                                         :enabled ""
                                                                                                         :filtering {:exclude [{}]
                                                                                                                     :include [{}]}
                                                                                                         :groupDuration 0
                                                                                                         :groupSize 0
                                                                                                         :id ""
                                                                                                         :jsonWorkers 0
                                                                                                         :location {:teams [{}]
                                                                                                                    :tenant ""}
                                                                                                         :metadata {}
                                                                                                         :name ""
                                                                                                         :projection {}
                                                                                                         :sendWorkers 0
                                                                                                         :typ ""}})

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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}}/api/data-exporter-configs/:dataExporterConfigId"),
    Content = new StringContent("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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}}/api/data-exporter-configs/:dataExporterConfigId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

	payload := strings.NewReader("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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/api/data-exporter-configs/:dataExporterConfigId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 381

{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .header("content-type", "application/json")
  .body("{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  bufferSize: 0,
  config: '',
  desc: '',
  enabled: '',
  filtering: {
    exclude: [
      {}
    ],
    include: [
      {}
    ]
  },
  groupDuration: 0,
  groupSize: 0,
  id: '',
  jsonWorkers: 0,
  location: {
    teams: [
      {}
    ],
    tenant: ''
  },
  metadata: {},
  name: '',
  projection: {},
  sendWorkers: 0,
  typ: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId',
  headers: {'content-type': 'application/json'},
  data: {
    bufferSize: 0,
    config: '',
    desc: '',
    enabled: '',
    filtering: {exclude: [{}], include: [{}]},
    groupDuration: 0,
    groupSize: 0,
    id: '',
    jsonWorkers: 0,
    location: {teams: [{}], tenant: ''},
    metadata: {},
    name: '',
    projection: {},
    sendWorkers: 0,
    typ: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"bufferSize":0,"config":"","desc":"","enabled":"","filtering":{"exclude":[{}],"include":[{}]},"groupDuration":0,"groupSize":0,"id":"","jsonWorkers":0,"location":{"teams":[{}],"tenant":""},"metadata":{},"name":"","projection":{},"sendWorkers":0,"typ":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bufferSize": 0,\n  "config": "",\n  "desc": "",\n  "enabled": "",\n  "filtering": {\n    "exclude": [\n      {}\n    ],\n    "include": [\n      {}\n    ]\n  },\n  "groupDuration": 0,\n  "groupSize": 0,\n  "id": "",\n  "jsonWorkers": 0,\n  "location": {\n    "teams": [\n      {}\n    ],\n    "tenant": ""\n  },\n  "metadata": {},\n  "name": "",\n  "projection": {},\n  "sendWorkers": 0,\n  "typ": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")
  .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/api/data-exporter-configs/:dataExporterConfigId',
  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({
  bufferSize: 0,
  config: '',
  desc: '',
  enabled: '',
  filtering: {exclude: [{}], include: [{}]},
  groupDuration: 0,
  groupSize: 0,
  id: '',
  jsonWorkers: 0,
  location: {teams: [{}], tenant: ''},
  metadata: {},
  name: '',
  projection: {},
  sendWorkers: 0,
  typ: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId',
  headers: {'content-type': 'application/json'},
  body: {
    bufferSize: 0,
    config: '',
    desc: '',
    enabled: '',
    filtering: {exclude: [{}], include: [{}]},
    groupDuration: 0,
    groupSize: 0,
    id: '',
    jsonWorkers: 0,
    location: {teams: [{}], tenant: ''},
    metadata: {},
    name: '',
    projection: {},
    sendWorkers: 0,
    typ: ''
  },
  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}}/api/data-exporter-configs/:dataExporterConfigId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  bufferSize: 0,
  config: '',
  desc: '',
  enabled: '',
  filtering: {
    exclude: [
      {}
    ],
    include: [
      {}
    ]
  },
  groupDuration: 0,
  groupSize: 0,
  id: '',
  jsonWorkers: 0,
  location: {
    teams: [
      {}
    ],
    tenant: ''
  },
  metadata: {},
  name: '',
  projection: {},
  sendWorkers: 0,
  typ: ''
});

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}}/api/data-exporter-configs/:dataExporterConfigId',
  headers: {'content-type': 'application/json'},
  data: {
    bufferSize: 0,
    config: '',
    desc: '',
    enabled: '',
    filtering: {exclude: [{}], include: [{}]},
    groupDuration: 0,
    groupSize: 0,
    id: '',
    jsonWorkers: 0,
    location: {teams: [{}], tenant: ''},
    metadata: {},
    name: '',
    projection: {},
    sendWorkers: 0,
    typ: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"bufferSize":0,"config":"","desc":"","enabled":"","filtering":{"exclude":[{}],"include":[{}]},"groupDuration":0,"groupSize":0,"id":"","jsonWorkers":0,"location":{"teams":[{}],"tenant":""},"metadata":{},"name":"","projection":{},"sendWorkers":0,"typ":""}'
};

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 = @{ @"bufferSize": @0,
                              @"config": @"",
                              @"desc": @"",
                              @"enabled": @"",
                              @"filtering": @{ @"exclude": @[ @{  } ], @"include": @[ @{  } ] },
                              @"groupDuration": @0,
                              @"groupSize": @0,
                              @"id": @"",
                              @"jsonWorkers": @0,
                              @"location": @{ @"teams": @[ @{  } ], @"tenant": @"" },
                              @"metadata": @{  },
                              @"name": @"",
                              @"projection": @{  },
                              @"sendWorkers": @0,
                              @"typ": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"]
                                                       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}}/api/data-exporter-configs/:dataExporterConfigId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId",
  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([
    'bufferSize' => 0,
    'config' => '',
    'desc' => '',
    'enabled' => '',
    'filtering' => [
        'exclude' => [
                [
                                
                ]
        ],
        'include' => [
                [
                                
                ]
        ]
    ],
    'groupDuration' => 0,
    'groupSize' => 0,
    'id' => '',
    'jsonWorkers' => 0,
    'location' => [
        'teams' => [
                [
                                
                ]
        ],
        'tenant' => ''
    ],
    'metadata' => [
        
    ],
    'name' => '',
    'projection' => [
        
    ],
    'sendWorkers' => 0,
    'typ' => ''
  ]),
  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}}/api/data-exporter-configs/:dataExporterConfigId', [
  'body' => '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bufferSize' => 0,
  'config' => '',
  'desc' => '',
  'enabled' => '',
  'filtering' => [
    'exclude' => [
        [
                
        ]
    ],
    'include' => [
        [
                
        ]
    ]
  ],
  'groupDuration' => 0,
  'groupSize' => 0,
  'id' => '',
  'jsonWorkers' => 0,
  'location' => [
    'teams' => [
        [
                
        ]
    ],
    'tenant' => ''
  ],
  'metadata' => [
    
  ],
  'name' => '',
  'projection' => [
    
  ],
  'sendWorkers' => 0,
  'typ' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'bufferSize' => 0,
  'config' => '',
  'desc' => '',
  'enabled' => '',
  'filtering' => [
    'exclude' => [
        [
                
        ]
    ],
    'include' => [
        [
                
        ]
    ]
  ],
  'groupDuration' => 0,
  'groupSize' => 0,
  'id' => '',
  'jsonWorkers' => 0,
  'location' => [
    'teams' => [
        [
                
        ]
    ],
    'tenant' => ''
  ],
  'metadata' => [
    
  ],
  'name' => '',
  'projection' => [
    
  ],
  'sendWorkers' => 0,
  'typ' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId');
$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}}/api/data-exporter-configs/:dataExporterConfigId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/data-exporter-configs/:dataExporterConfigId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

payload = {
    "bufferSize": 0,
    "config": "",
    "desc": "",
    "enabled": "",
    "filtering": {
        "exclude": [{}],
        "include": [{}]
    },
    "groupDuration": 0,
    "groupSize": 0,
    "id": "",
    "jsonWorkers": 0,
    "location": {
        "teams": [{}],
        "tenant": ""
    },
    "metadata": {},
    "name": "",
    "projection": {},
    "sendWorkers": 0,
    "typ": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId"

payload <- "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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}}/api/data-exporter-configs/:dataExporterConfigId")

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  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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/api/data-exporter-configs/:dataExporterConfigId') do |req|
  req.body = "{\n  \"bufferSize\": 0,\n  \"config\": \"\",\n  \"desc\": \"\",\n  \"enabled\": \"\",\n  \"filtering\": {\n    \"exclude\": [\n      {}\n    ],\n    \"include\": [\n      {}\n    ]\n  },\n  \"groupDuration\": 0,\n  \"groupSize\": 0,\n  \"id\": \"\",\n  \"jsonWorkers\": 0,\n  \"location\": {\n    \"teams\": [\n      {}\n    ],\n    \"tenant\": \"\"\n  },\n  \"metadata\": {},\n  \"name\": \"\",\n  \"projection\": {},\n  \"sendWorkers\": 0,\n  \"typ\": \"\"\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}}/api/data-exporter-configs/:dataExporterConfigId";

    let payload = json!({
        "bufferSize": 0,
        "config": "",
        "desc": "",
        "enabled": "",
        "filtering": json!({
            "exclude": (json!({})),
            "include": (json!({}))
        }),
        "groupDuration": 0,
        "groupSize": 0,
        "id": "",
        "jsonWorkers": 0,
        "location": json!({
            "teams": (json!({})),
            "tenant": ""
        }),
        "metadata": json!({}),
        "name": "",
        "projection": json!({}),
        "sendWorkers": 0,
        "typ": ""
    });

    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}}/api/data-exporter-configs/:dataExporterConfigId \
  --header 'content-type: application/json' \
  --data '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}'

echo '{
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": {
    "exclude": [
      {}
    ],
    "include": [
      {}
    ]
  },
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": {
    "teams": [
      {}
    ],
    "tenant": ""
  },
  "metadata": {},
  "name": "",
  "projection": {},
  "sendWorkers": 0,
  "typ": ""
}' |  \
  http PUT {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "bufferSize": 0,\n  "config": "",\n  "desc": "",\n  "enabled": "",\n  "filtering": {\n    "exclude": [\n      {}\n    ],\n    "include": [\n      {}\n    ]\n  },\n  "groupDuration": 0,\n  "groupSize": 0,\n  "id": "",\n  "jsonWorkers": 0,\n  "location": {\n    "teams": [\n      {}\n    ],\n    "tenant": ""\n  },\n  "metadata": {},\n  "name": "",\n  "projection": {},\n  "sendWorkers": 0,\n  "typ": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "bufferSize": 0,
  "config": "",
  "desc": "",
  "enabled": "",
  "filtering": [
    "exclude": [[]],
    "include": [[]]
  ],
  "groupDuration": 0,
  "groupSize": 0,
  "id": "",
  "jsonWorkers": 0,
  "location": [
    "teams": [[]],
    "tenant": ""
  ],
  "metadata": [],
  "name": "",
  "projection": [],
  "sendWorkers": 0,
  "typ": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/:dataExporterConfigId")! 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

{
  "bufferSize": 123123,
  "desc": "a string value",
  "enabled": "a string value",
  "groupDuration": 123,
  "groupSize": 123123,
  "id": "a string value",
  "jsonWorkers": 123123,
  "location": {
    "tenant": "a string value"
  },
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "projection": {
    "key": "value"
  },
  "sendWorkers": 123123
}

PATCH Update a data exporter configs with a diff

{{baseUrl}}/api/data-exporter-configs/_bulk

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/_bulk");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/data-exporter-configs/_bulk")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/data-exporter-configs/_bulk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs/_bulk");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/_bulk"

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/api/data-exporter-configs/_bulk HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/data-exporter-configs/_bulk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/_bulk"))
    .method("PATCH", 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}}/api/data-exporter-configs/_bulk")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .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('PATCH', '{{baseUrl}}/api/data-exporter-configs/_bulk');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/data-exporter-configs/_bulk',
  method: 'PATCH',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/_bulk',
  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: 'PATCH',
  url: '{{baseUrl}}/api/data-exporter-configs/_bulk'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/data-exporter-configs/_bulk');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
const options = {method: 'PATCH'};

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}}/api/data-exporter-configs/_bulk"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/data-exporter-configs/_bulk" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/_bulk",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/api/data-exporter-configs/_bulk');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method PATCH

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method PATCH

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PATCH", "/baseUrl/api/data-exporter-configs/_bulk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/_bulk"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/_bulk")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/api/data-exporter-configs/_bulk') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/_bulk";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/data-exporter-configs/_bulk

http PATCH {{baseUrl}}/api/data-exporter-configs/_bulk

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/_bulk

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/_bulk")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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

[
  {
    "id": true,
    "updated": true
  }
]

PUT Update a data exporter configs

{{baseUrl}}/api/data-exporter-configs/_bulk

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/data-exporter-configs/_bulk");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/data-exporter-configs/_bulk")

require "http/client"

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

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}}/api/data-exporter-configs/_bulk"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/data-exporter-configs/_bulk");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/data-exporter-configs/_bulk"

	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/api/data-exporter-configs/_bulk HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/data-exporter-configs/_bulk")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/data-exporter-configs/_bulk"))
    .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}}/api/data-exporter-configs/_bulk")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .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}}/api/data-exporter-configs/_bulk');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
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}}/api/data-exporter-configs/_bulk',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/data-exporter-configs/_bulk")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/data-exporter-configs/_bulk',
  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}}/api/data-exporter-configs/_bulk'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/data-exporter-configs/_bulk');

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}}/api/data-exporter-configs/_bulk'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/data-exporter-configs/_bulk';
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}}/api/data-exporter-configs/_bulk"]
                                                       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}}/api/data-exporter-configs/_bulk" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/data-exporter-configs/_bulk",
  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}}/api/data-exporter-configs/_bulk');

echo $response->getBody();

setUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/data-exporter-configs/_bulk');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/data-exporter-configs/_bulk' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/api/data-exporter-configs/_bulk")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/data-exporter-configs/_bulk"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/data-exporter-configs/_bulk"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/data-exporter-configs/_bulk")

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/api/data-exporter-configs/_bulk') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/data-exporter-configs/_bulk";

    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}}/api/data-exporter-configs/_bulk

http PUT {{baseUrl}}/api/data-exporter-configs/_bulk

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/api/data-exporter-configs/_bulk

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/data-exporter-configs/_bulk")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "id": true,
    "updated": true
  }
]

POST Create a new service group

{{baseUrl}}/api/groups

BODY json

{
  "description": "",
  "id": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups");

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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/groups" {:content-type :json
                                                       :form-params {:description ""
                                                                     :id ""
                                                                     :name ""}})

require "http/client"

url = "{{baseUrl}}/api/groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/groups"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"id\": \"\",\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/api/groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "description": "",
  "id": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"id\": \"\",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/groups")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  id: '',
  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}}/api/groups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/groups',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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}}/api/groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "id": "",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/groups")
  .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/api/groups',
  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({description: '', id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/groups',
  headers: {'content-type': 'application/json'},
  body: {description: '', id: '', 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}}/api/groups');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  id: '',
  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}}/api/groups',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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 = @{ @"description": @"",
                              @"id": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/groups"]
                                                       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}}/api/groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/groups",
  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([
    'description' => '',
    'id' => '',
    '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}}/api/groups', [
  'body' => '{
  "description": "",
  "id": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/groups');
$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}}/api/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/groups", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/groups"

payload = {
    "description": "",
    "id": "",
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups"

payload <- "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups")

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  \"description\": \"\",\n  \"id\": \"\",\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/api/groups') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups";

    let payload = json!({
        "description": "",
        "id": "",
        "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}}/api/groups \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "id": "",
  "name": ""
}'

echo '{
  "description": "",
  "id": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/api/groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "id": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "id": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups")! 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

{
  "description": "a string value",
  "id": "a string value",
  "name": "a string value"
}

DELETE Delete a service group

{{baseUrl}}/api/groups/:serviceGroupId

QUERY PARAMS

serviceGroupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:serviceGroupId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/groups/:serviceGroupId")

require "http/client"

url = "{{baseUrl}}/api/groups/:serviceGroupId"

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}}/api/groups/:serviceGroupId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/groups/:serviceGroupId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/groups/:serviceGroupId"

	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/api/groups/:serviceGroupId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/groups/:serviceGroupId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:serviceGroupId"))
    .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}}/api/groups/:serviceGroupId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/groups/:serviceGroupId")
  .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}}/api/groups/:serviceGroupId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/groups/:serviceGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
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}}/api/groups/:serviceGroupId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:serviceGroupId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/groups/:serviceGroupId',
  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}}/api/groups/:serviceGroupId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/groups/:serviceGroupId');

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}}/api/groups/:serviceGroupId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
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}}/api/groups/:serviceGroupId"]
                                                       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}}/api/groups/:serviceGroupId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/groups/:serviceGroupId",
  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}}/api/groups/:serviceGroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:serviceGroupId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:serviceGroupId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/groups/:serviceGroupId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/groups/:serviceGroupId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:serviceGroupId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:serviceGroupId")

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/api/groups/:serviceGroupId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:serviceGroupId";

    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}}/api/groups/:serviceGroupId

http DELETE {{baseUrl}}/api/groups/:serviceGroupId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/groups/:serviceGroupId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups/:serviceGroupId")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get a service group

{{baseUrl}}/api/groups/:serviceGroupId

QUERY PARAMS

serviceGroupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:serviceGroupId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/groups/:serviceGroupId")

require "http/client"

url = "{{baseUrl}}/api/groups/:serviceGroupId"

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}}/api/groups/:serviceGroupId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/groups/:serviceGroupId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/groups/:serviceGroupId"

	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/api/groups/:serviceGroupId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/groups/:serviceGroupId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:serviceGroupId"))
    .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}}/api/groups/:serviceGroupId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/groups/:serviceGroupId")
  .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}}/api/groups/:serviceGroupId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/groups/:serviceGroupId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
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}}/api/groups/:serviceGroupId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:serviceGroupId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/groups/:serviceGroupId',
  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}}/api/groups/:serviceGroupId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/groups/:serviceGroupId');

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}}/api/groups/:serviceGroupId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
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}}/api/groups/:serviceGroupId"]
                                                       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}}/api/groups/:serviceGroupId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/groups/:serviceGroupId",
  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}}/api/groups/:serviceGroupId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:serviceGroupId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:serviceGroupId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/groups/:serviceGroupId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/groups/:serviceGroupId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:serviceGroupId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:serviceGroupId")

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/api/groups/:serviceGroupId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:serviceGroupId";

    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}}/api/groups/:serviceGroupId

http GET {{baseUrl}}/api/groups/:serviceGroupId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/groups/:serviceGroupId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups/:serviceGroupId")! 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": "a string value",
  "id": "a string value",
  "name": "a string value"
}

GET Get all service groups

{{baseUrl}}/api/groups

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/groups")

require "http/client"

url = "{{baseUrl}}/api/groups"

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}}/api/groups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/groups"

	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/api/groups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/groups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups"))
    .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}}/api/groups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/groups")
  .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}}/api/groups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/groups';
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}}/api/groups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/groups',
  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}}/api/groups'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/groups');

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}}/api/groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/groups';
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}}/api/groups"]
                                                       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}}/api/groups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/groups",
  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}}/api/groups');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/groups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/groups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups")

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/api/groups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups";

    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}}/api/groups

http GET {{baseUrl}}/api/groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/groups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups")! 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": "a string value",
    "id": "a string value",
    "name": "a string value"
  }
]

PATCH Update a service group with a diff

{{baseUrl}}/api/groups/:serviceGroupId

QUERY PARAMS

serviceGroupId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:serviceGroupId");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/groups/:serviceGroupId" {:content-type :json
                                                                        :form-params [{:op ""
                                                                                       :path ""
                                                                                       :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/groups/:serviceGroupId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/groups/:serviceGroupId"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/groups/:serviceGroupId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/groups/:serviceGroupId"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/groups/:serviceGroupId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/groups/:serviceGroupId")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:serviceGroupId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/groups/:serviceGroupId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/groups/:serviceGroupId")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/groups/:serviceGroupId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/groups/:serviceGroupId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/groups/:serviceGroupId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:serviceGroupId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/groups/:serviceGroupId',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/groups/:serviceGroupId',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/groups/:serviceGroupId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/groups/:serviceGroupId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/groups/:serviceGroupId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/groups/:serviceGroupId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/groups/:serviceGroupId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/groups/:serviceGroupId', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$request->setRequestMethod('PATCH');
$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}}/api/groups/:serviceGroupId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:serviceGroupId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/groups/:serviceGroupId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/groups/:serviceGroupId"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:serviceGroupId"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:serviceGroupId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/groups/:serviceGroupId') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:serviceGroupId";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/groups/:serviceGroupId \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/groups/:serviceGroupId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/groups/:serviceGroupId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups/:serviceGroupId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "description": "a string value",
  "id": "a string value",
  "name": "a string value"
}

PUT Update a service group

{{baseUrl}}/api/groups/:serviceGroupId

QUERY PARAMS

serviceGroupId

BODY json

{
  "description": "",
  "id": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:serviceGroupId");

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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/groups/:serviceGroupId" {:content-type :json
                                                                      :form-params {:description ""
                                                                                    :id ""
                                                                                    :name ""}})

require "http/client"

url = "{{baseUrl}}/api/groups/:serviceGroupId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups/:serviceGroupId"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups/:serviceGroupId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/groups/:serviceGroupId"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"id\": \"\",\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/api/groups/:serviceGroupId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "description": "",
  "id": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/groups/:serviceGroupId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:serviceGroupId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"id\": \"\",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/groups/:serviceGroupId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/groups/:serviceGroupId")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  id: '',
  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}}/api/groups/:serviceGroupId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/groups/:serviceGroupId',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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}}/api/groups/:serviceGroupId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "id": "",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:serviceGroupId")
  .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/api/groups/:serviceGroupId',
  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({description: '', id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/groups/:serviceGroupId',
  headers: {'content-type': 'application/json'},
  body: {description: '', id: '', 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}}/api/groups/:serviceGroupId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  id: '',
  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}}/api/groups/:serviceGroupId',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/groups/:serviceGroupId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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 = @{ @"description": @"",
                              @"id": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/groups/:serviceGroupId"]
                                                       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}}/api/groups/:serviceGroupId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/groups/:serviceGroupId",
  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([
    'description' => '',
    'id' => '',
    '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}}/api/groups/:serviceGroupId', [
  'body' => '{
  "description": "",
  "id": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/groups/:serviceGroupId');
$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}}/api/groups/:serviceGroupId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:serviceGroupId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/groups/:serviceGroupId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/groups/:serviceGroupId"

payload = {
    "description": "",
    "id": "",
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:serviceGroupId"

payload <- "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups/:serviceGroupId")

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  \"description\": \"\",\n  \"id\": \"\",\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/api/groups/:serviceGroupId') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/groups/:serviceGroupId";

    let payload = json!({
        "description": "",
        "id": "",
        "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}}/api/groups/:serviceGroupId \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "id": "",
  "name": ""
}'

echo '{
  "description": "",
  "id": "",
  "name": ""
}' |  \
  http PUT {{baseUrl}}/api/groups/:serviceGroupId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "id": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/groups/:serviceGroupId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "id": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups/:serviceGroupId")! 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

{
  "description": "a string value",
  "id": "a string value",
  "name": "a string value"
}

GET Return current Otoroshi health

{{baseUrl}}/health

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/health");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/health")

require "http/client"

url = "{{baseUrl}}/health"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/health"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/health");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/health"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/health HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/health")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/health"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/health")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/health")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/health');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/health'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/health';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/health',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/health")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/health',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/health'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/health');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/health'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/health';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/health"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/health" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/health",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/health');

echo $response->getBody();

setUrl('{{baseUrl}}/health');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/health');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/health' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/health' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/health")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/health"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/health"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/health') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/health";

    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}}/health

http GET {{baseUrl}}/health

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/health

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/health")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Export the full state of Otoroshi

{{baseUrl}}/api/otoroshi.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/otoroshi.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/otoroshi.json")

require "http/client"

url = "{{baseUrl}}/api/otoroshi.json"

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}}/api/otoroshi.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/otoroshi.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/otoroshi.json"

	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/api/otoroshi.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/otoroshi.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/otoroshi.json"))
    .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}}/api/otoroshi.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/otoroshi.json")
  .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}}/api/otoroshi.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/otoroshi.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/otoroshi.json';
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}}/api/otoroshi.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/otoroshi.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/otoroshi.json',
  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}}/api/otoroshi.json'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/otoroshi.json');

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}}/api/otoroshi.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/otoroshi.json';
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}}/api/otoroshi.json"]
                                                       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}}/api/otoroshi.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/otoroshi.json",
  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}}/api/otoroshi.json');

echo $response->getBody();

setUrl('{{baseUrl}}/api/otoroshi.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/otoroshi.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/otoroshi.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/otoroshi.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/otoroshi.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/otoroshi.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/otoroshi.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/otoroshi.json")

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/api/otoroshi.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/otoroshi.json";

    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}}/api/otoroshi.json

http GET {{baseUrl}}/api/otoroshi.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/otoroshi.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/otoroshi.json")! 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

{
  "appConfig": {
    "key": "value"
  },
  "config": {
    "apiReadOnly": true,
    "autoLinkToDefaultGroup": true,
    "limitConcurrentRequests": true,
    "maxConcurrentRequests": 123,
    "maxHttp10ResponseSize": 123,
    "maxLogsSize": 123123,
    "middleFingers": true,
    "perIpThrottlingQuota": 123,
    "streamEntityOnly": true,
    "throttlingQuota": 123,
    "u2fLoginOnly": true,
    "useCircuitBreakers": true
  },
  "date": "2017-07-21T17:32:28Z",
  "dateRaw": 123,
  "label": "a string value",
  "stats": {
    "calls": 123,
    "dataIn": 123,
    "dataOut": 123
  }
}

POST Import the full state of Otoroshi as a file

{{baseUrl}}/api/import

BODY json

{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/import");

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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/import" {:content-type :json
                                                       :form-params {:admins [{:createdAt 0
                                                                               :label ""
                                                                               :password ""
                                                                               :registration {}
                                                                               :username ""}]
                                                                     :apiKeys [{:authorizedEntities []
                                                                                :clientId ""
                                                                                :clientName ""
                                                                                :clientSecret ""
                                                                                :dailyQuota 0
                                                                                :enabled false
                                                                                :metadata {}
                                                                                :monthlyQuota 0
                                                                                :throttlingQuota 0}]
                                                                     :appConfig {}
                                                                     :config {:alertsEmails []
                                                                              :alertsWebhooks [{:headers {}
                                                                                                :url ""}]
                                                                              :analyticsWebhooks [{}]
                                                                              :apiReadOnly false
                                                                              :autoLinkToDefaultGroup false
                                                                              :backofficeAuth0Config {:callbackUrl ""
                                                                                                      :clientId ""
                                                                                                      :clientSecret ""
                                                                                                      :domain ""}
                                                                              :cleverSettings {:consumerKey ""
                                                                                               :consumerSecret ""
                                                                                               :orgaId ""
                                                                                               :secret ""
                                                                                               :token ""}
                                                                              :elasticReadsConfig {:clusterUri ""
                                                                                                   :headers {}
                                                                                                   :index ""
                                                                                                   :password ""
                                                                                                   :type ""
                                                                                                   :user ""}
                                                                              :elasticWritesConfigs [{}]
                                                                              :endlessIpAddresses []
                                                                              :ipFiltering {:blacklist []
                                                                                            :whitelist []}
                                                                              :limitConcurrentRequests false
                                                                              :lines []
                                                                              :mailerSettings {:apiKey ""
                                                                                               :apiKeyPrivate ""
                                                                                               :apiKeyPublic ""
                                                                                               :domain ""
                                                                                               :eu false
                                                                                               :header {}
                                                                                               :type ""
                                                                                               :url ""}
                                                                              :maxConcurrentRequests 0
                                                                              :maxHttp10ResponseSize 0
                                                                              :maxLogsSize 0
                                                                              :middleFingers false
                                                                              :perIpThrottlingQuota 0
                                                                              :privateAppsAuth0Config {}
                                                                              :streamEntityOnly false
                                                                              :throttlingQuota 0
                                                                              :u2fLoginOnly false
                                                                              :useCircuitBreakers false}
                                                                     :date ""
                                                                     :dateRaw 0
                                                                     :errorTemplates [{:messages {}
                                                                                       :serviceId ""
                                                                                       :template40x ""
                                                                                       :template50x ""
                                                                                       :templateBuild ""
                                                                                       :templateMaintenance ""}]
                                                                     :label ""
                                                                     :serviceDescriptors [{:Canary {:enabled false
                                                                                                    :root ""
                                                                                                    :targets [{:host ""
                                                                                                               :scheme ""}]
                                                                                                    :traffic 0}
                                                                                           :additionalHeaders {}
                                                                                           :api {:exposeApi false
                                                                                                 :openApiDescriptorUrl ""}
                                                                                           :authConfigRef ""
                                                                                           :buildMode false
                                                                                           :chaosConfig {:badResponsesFaultConfig {:ratio ""
                                                                                                                                   :responses [{:body ""
                                                                                                                                                :headers {}
                                                                                                                                                :status 0}]}
                                                                                                         :enabled false
                                                                                                         :largeRequestFaultConfig {:additionalRequestSize 0
                                                                                                                                   :ratio ""}
                                                                                                         :largeResponseFaultConfig {:additionalRequestSize 0
                                                                                                                                    :ratio ""}
                                                                                                         :latencyInjectionFaultConfig {:from 0
                                                                                                                                       :ratio ""
                                                                                                                                       :to 0}}
                                                                                           :clientConfig {:backoffFactor 0
                                                                                                          :callTimeout 0
                                                                                                          :globalTimeout 0
                                                                                                          :maxErrors 0
                                                                                                          :retries 0
                                                                                                          :retryInitialDelay 0
                                                                                                          :sampleInterval 0
                                                                                                          :useCircuitBreaker false}
                                                                                           :clientValidatorRef ""
                                                                                           :cors {:allowCredentials false
                                                                                                  :allowHeaders []
                                                                                                  :allowMethods []
                                                                                                  :allowOrigin ""
                                                                                                  :enabled false
                                                                                                  :excludedPatterns []
                                                                                                  :exposeHeaders []
                                                                                                  :maxAge 0}
                                                                                           :domain ""
                                                                                           :enabled false
                                                                                           :enforceSecureCommunication false
                                                                                           :env ""
                                                                                           :forceHttps false
                                                                                           :groups []
                                                                                           :gzip {:blackList []
                                                                                                  :bufferSize 0
                                                                                                  :chunkedThreshold 0
                                                                                                  :compressionLevel 0
                                                                                                  :enabled false
                                                                                                  :excludedPatterns []
                                                                                                  :whiteList []}
                                                                                           :headersVerification {}
                                                                                           :healthCheck {:enabled false
                                                                                                         :url ""}
                                                                                           :id ""
                                                                                           :ipFiltering {}
                                                                                           :jwtVerifier ""
                                                                                           :localHost ""
                                                                                           :localScheme ""
                                                                                           :maintenanceMode false
                                                                                           :matchingHeaders {}
                                                                                           :matchingRoot ""
                                                                                           :metadata {}
                                                                                           :name ""
                                                                                           :overrideHost false
                                                                                           :privateApp false
                                                                                           :privatePatterns []
                                                                                           :publicPatterns []
                                                                                           :redirectToLocal false
                                                                                           :redirection {:code 0
                                                                                                         :enabled false
                                                                                                         :to ""}
                                                                                           :root ""
                                                                                           :secComExcludedPatterns []
                                                                                           :secComSettings ""
                                                                                           :sendOtoroshiHeadersBack false
                                                                                           :statsdConfig {:datadog false
                                                                                                          :host ""
                                                                                                          :port 0}
                                                                                           :subdomain ""
                                                                                           :targets [{}]
                                                                                           :transformerRef ""
                                                                                           :userFacing false
                                                                                           :xForwardedHeaders false}]
                                                                     :serviceGroups [{:description ""
                                                                                      :id ""
                                                                                      :name ""}]
                                                                     :simpleAdmins [{:createdAt 0
                                                                                     :label ""
                                                                                     :password ""
                                                                                     :username ""}]
                                                                     :stats {:calls 0
                                                                             :dataIn 0
                                                                             :dataOut 0}}})

require "http/client"

url = "{{baseUrl}}/api/import"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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}}/api/import"),
    Content = new StringContent("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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}}/api/import");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/import"

	payload := strings.NewReader("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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/api/import HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 5188

{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/import")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/import"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/import")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/import")
  .header("content-type", "application/json")
  .body("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}")
  .asString();

const data = JSON.stringify({
  admins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      registration: {},
      username: ''
    }
  ],
  apiKeys: [
    {
      authorizedEntities: [],
      clientId: '',
      clientName: '',
      clientSecret: '',
      dailyQuota: 0,
      enabled: false,
      metadata: {},
      monthlyQuota: 0,
      throttlingQuota: 0
    }
  ],
  appConfig: {},
  config: {
    alertsEmails: [],
    alertsWebhooks: [
      {
        headers: {},
        url: ''
      }
    ],
    analyticsWebhooks: [
      {}
    ],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {
      callbackUrl: '',
      clientId: '',
      clientSecret: '',
      domain: ''
    },
    cleverSettings: {
      consumerKey: '',
      consumerSecret: '',
      orgaId: '',
      secret: '',
      token: ''
    },
    elasticReadsConfig: {
      clusterUri: '',
      headers: {},
      index: '',
      password: '',
      type: '',
      user: ''
    },
    elasticWritesConfigs: [
      {}
    ],
    endlessIpAddresses: [],
    ipFiltering: {
      blacklist: [],
      whitelist: []
    },
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  },
  date: '',
  dateRaw: 0,
  errorTemplates: [
    {
      messages: {},
      serviceId: '',
      template40x: '',
      template50x: '',
      templateBuild: '',
      templateMaintenance: ''
    }
  ],
  label: '',
  serviceDescriptors: [
    {
      Canary: {
        enabled: false,
        root: '',
        targets: [
          {
            host: '',
            scheme: ''
          }
        ],
        traffic: 0
      },
      additionalHeaders: {},
      api: {
        exposeApi: false,
        openApiDescriptorUrl: ''
      },
      authConfigRef: '',
      buildMode: false,
      chaosConfig: {
        badResponsesFaultConfig: {
          ratio: '',
          responses: [
            {
              body: '',
              headers: {},
              status: 0
            }
          ]
        },
        enabled: false,
        largeRequestFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        largeResponseFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        latencyInjectionFaultConfig: {
          from: 0,
          ratio: '',
          to: 0
        }
      },
      clientConfig: {
        backoffFactor: 0,
        callTimeout: 0,
        globalTimeout: 0,
        maxErrors: 0,
        retries: 0,
        retryInitialDelay: 0,
        sampleInterval: 0,
        useCircuitBreaker: false
      },
      clientValidatorRef: '',
      cors: {
        allowCredentials: false,
        allowHeaders: [],
        allowMethods: [],
        allowOrigin: '',
        enabled: false,
        excludedPatterns: [],
        exposeHeaders: [],
        maxAge: 0
      },
      domain: '',
      enabled: false,
      enforceSecureCommunication: false,
      env: '',
      forceHttps: false,
      groups: [],
      gzip: {
        blackList: [],
        bufferSize: 0,
        chunkedThreshold: 0,
        compressionLevel: 0,
        enabled: false,
        excludedPatterns: [],
        whiteList: []
      },
      headersVerification: {},
      healthCheck: {
        enabled: false,
        url: ''
      },
      id: '',
      ipFiltering: {},
      jwtVerifier: '',
      localHost: '',
      localScheme: '',
      maintenanceMode: false,
      matchingHeaders: {},
      matchingRoot: '',
      metadata: {},
      name: '',
      overrideHost: false,
      privateApp: false,
      privatePatterns: [],
      publicPatterns: [],
      redirectToLocal: false,
      redirection: {
        code: 0,
        enabled: false,
        to: ''
      },
      root: '',
      secComExcludedPatterns: [],
      secComSettings: '',
      sendOtoroshiHeadersBack: false,
      statsdConfig: {
        datadog: false,
        host: '',
        port: 0
      },
      subdomain: '',
      targets: [
        {}
      ],
      transformerRef: '',
      userFacing: false,
      xForwardedHeaders: false
    }
  ],
  serviceGroups: [
    {
      description: '',
      id: '',
      name: ''
    }
  ],
  simpleAdmins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      username: ''
    }
  ],
  stats: {
    calls: 0,
    dataIn: 0,
    dataOut: 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}}/api/import');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/import',
  headers: {'content-type': 'application/json'},
  data: {
    admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
    apiKeys: [
      {
        authorizedEntities: [],
        clientId: '',
        clientName: '',
        clientSecret: '',
        dailyQuota: 0,
        enabled: false,
        metadata: {},
        monthlyQuota: 0,
        throttlingQuota: 0
      }
    ],
    appConfig: {},
    config: {
      alertsEmails: [],
      alertsWebhooks: [{headers: {}, url: ''}],
      analyticsWebhooks: [{}],
      apiReadOnly: false,
      autoLinkToDefaultGroup: false,
      backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
      cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
      elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
      elasticWritesConfigs: [{}],
      endlessIpAddresses: [],
      ipFiltering: {blacklist: [], whitelist: []},
      limitConcurrentRequests: false,
      lines: [],
      mailerSettings: {
        apiKey: '',
        apiKeyPrivate: '',
        apiKeyPublic: '',
        domain: '',
        eu: false,
        header: {},
        type: '',
        url: ''
      },
      maxConcurrentRequests: 0,
      maxHttp10ResponseSize: 0,
      maxLogsSize: 0,
      middleFingers: false,
      perIpThrottlingQuota: 0,
      privateAppsAuth0Config: {},
      streamEntityOnly: false,
      throttlingQuota: 0,
      u2fLoginOnly: false,
      useCircuitBreakers: false
    },
    date: '',
    dateRaw: 0,
    errorTemplates: [
      {
        messages: {},
        serviceId: '',
        template40x: '',
        template50x: '',
        templateBuild: '',
        templateMaintenance: ''
      }
    ],
    label: '',
    serviceDescriptors: [
      {
        Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
        additionalHeaders: {},
        api: {exposeApi: false, openApiDescriptorUrl: ''},
        authConfigRef: '',
        buildMode: false,
        chaosConfig: {
          badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
          enabled: false,
          largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
          largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
          latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
        },
        clientConfig: {
          backoffFactor: 0,
          callTimeout: 0,
          globalTimeout: 0,
          maxErrors: 0,
          retries: 0,
          retryInitialDelay: 0,
          sampleInterval: 0,
          useCircuitBreaker: false
        },
        clientValidatorRef: '',
        cors: {
          allowCredentials: false,
          allowHeaders: [],
          allowMethods: [],
          allowOrigin: '',
          enabled: false,
          excludedPatterns: [],
          exposeHeaders: [],
          maxAge: 0
        },
        domain: '',
        enabled: false,
        enforceSecureCommunication: false,
        env: '',
        forceHttps: false,
        groups: [],
        gzip: {
          blackList: [],
          bufferSize: 0,
          chunkedThreshold: 0,
          compressionLevel: 0,
          enabled: false,
          excludedPatterns: [],
          whiteList: []
        },
        headersVerification: {},
        healthCheck: {enabled: false, url: ''},
        id: '',
        ipFiltering: {},
        jwtVerifier: '',
        localHost: '',
        localScheme: '',
        maintenanceMode: false,
        matchingHeaders: {},
        matchingRoot: '',
        metadata: {},
        name: '',
        overrideHost: false,
        privateApp: false,
        privatePatterns: [],
        publicPatterns: [],
        redirectToLocal: false,
        redirection: {code: 0, enabled: false, to: ''},
        root: '',
        secComExcludedPatterns: [],
        secComSettings: '',
        sendOtoroshiHeadersBack: false,
        statsdConfig: {datadog: false, host: '', port: 0},
        subdomain: '',
        targets: [{}],
        transformerRef: '',
        userFacing: false,
        xForwardedHeaders: false
      }
    ],
    serviceGroups: [{description: '', id: '', name: ''}],
    simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
    stats: {calls: 0, dataIn: 0, dataOut: 0}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"admins":[{"createdAt":0,"label":"","password":"","registration":{},"username":""}],"apiKeys":[{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":0}],"appConfig":{},"config":{"alertsEmails":[],"alertsWebhooks":[{"headers":{},"url":""}],"analyticsWebhooks":[{}],"apiReadOnly":false,"autoLinkToDefaultGroup":false,"backofficeAuth0Config":{"callbackUrl":"","clientId":"","clientSecret":"","domain":""},"cleverSettings":{"consumerKey":"","consumerSecret":"","orgaId":"","secret":"","token":""},"elasticReadsConfig":{"clusterUri":"","headers":{},"index":"","password":"","type":"","user":""},"elasticWritesConfigs":[{}],"endlessIpAddresses":[],"ipFiltering":{"blacklist":[],"whitelist":[]},"limitConcurrentRequests":false,"lines":[],"mailerSettings":{"apiKey":"","apiKeyPrivate":"","apiKeyPublic":"","domain":"","eu":false,"header":{},"type":"","url":""},"maxConcurrentRequests":0,"maxHttp10ResponseSize":0,"maxLogsSize":0,"middleFingers":false,"perIpThrottlingQuota":0,"privateAppsAuth0Config":{},"streamEntityOnly":false,"throttlingQuota":0,"u2fLoginOnly":false,"useCircuitBreakers":false},"date":"","dateRaw":0,"errorTemplates":[{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}],"label":"","serviceDescriptors":[{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}],"serviceGroups":[{"description":"","id":"","name":""}],"simpleAdmins":[{"createdAt":0,"label":"","password":"","username":""}],"stats":{"calls":0,"dataIn":0,"dataOut":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}}/api/import',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "admins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "registration": {},\n      "username": ""\n    }\n  ],\n  "apiKeys": [\n    {\n      "authorizedEntities": [],\n      "clientId": "",\n      "clientName": "",\n      "clientSecret": "",\n      "dailyQuota": 0,\n      "enabled": false,\n      "metadata": {},\n      "monthlyQuota": 0,\n      "throttlingQuota": 0\n    }\n  ],\n  "appConfig": {},\n  "config": {\n    "alertsEmails": [],\n    "alertsWebhooks": [\n      {\n        "headers": {},\n        "url": ""\n      }\n    ],\n    "analyticsWebhooks": [\n      {}\n    ],\n    "apiReadOnly": false,\n    "autoLinkToDefaultGroup": false,\n    "backofficeAuth0Config": {\n      "callbackUrl": "",\n      "clientId": "",\n      "clientSecret": "",\n      "domain": ""\n    },\n    "cleverSettings": {\n      "consumerKey": "",\n      "consumerSecret": "",\n      "orgaId": "",\n      "secret": "",\n      "token": ""\n    },\n    "elasticReadsConfig": {\n      "clusterUri": "",\n      "headers": {},\n      "index": "",\n      "password": "",\n      "type": "",\n      "user": ""\n    },\n    "elasticWritesConfigs": [\n      {}\n    ],\n    "endlessIpAddresses": [],\n    "ipFiltering": {\n      "blacklist": [],\n      "whitelist": []\n    },\n    "limitConcurrentRequests": false,\n    "lines": [],\n    "mailerSettings": {\n      "apiKey": "",\n      "apiKeyPrivate": "",\n      "apiKeyPublic": "",\n      "domain": "",\n      "eu": false,\n      "header": {},\n      "type": "",\n      "url": ""\n    },\n    "maxConcurrentRequests": 0,\n    "maxHttp10ResponseSize": 0,\n    "maxLogsSize": 0,\n    "middleFingers": false,\n    "perIpThrottlingQuota": 0,\n    "privateAppsAuth0Config": {},\n    "streamEntityOnly": false,\n    "throttlingQuota": 0,\n    "u2fLoginOnly": false,\n    "useCircuitBreakers": false\n  },\n  "date": "",\n  "dateRaw": 0,\n  "errorTemplates": [\n    {\n      "messages": {},\n      "serviceId": "",\n      "template40x": "",\n      "template50x": "",\n      "templateBuild": "",\n      "templateMaintenance": ""\n    }\n  ],\n  "label": "",\n  "serviceDescriptors": [\n    {\n      "Canary": {\n        "enabled": false,\n        "root": "",\n        "targets": [\n          {\n            "host": "",\n            "scheme": ""\n          }\n        ],\n        "traffic": 0\n      },\n      "additionalHeaders": {},\n      "api": {\n        "exposeApi": false,\n        "openApiDescriptorUrl": ""\n      },\n      "authConfigRef": "",\n      "buildMode": false,\n      "chaosConfig": {\n        "badResponsesFaultConfig": {\n          "ratio": "",\n          "responses": [\n            {\n              "body": "",\n              "headers": {},\n              "status": 0\n            }\n          ]\n        },\n        "enabled": false,\n        "largeRequestFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "largeResponseFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "latencyInjectionFaultConfig": {\n          "from": 0,\n          "ratio": "",\n          "to": 0\n        }\n      },\n      "clientConfig": {\n        "backoffFactor": 0,\n        "callTimeout": 0,\n        "globalTimeout": 0,\n        "maxErrors": 0,\n        "retries": 0,\n        "retryInitialDelay": 0,\n        "sampleInterval": 0,\n        "useCircuitBreaker": false\n      },\n      "clientValidatorRef": "",\n      "cors": {\n        "allowCredentials": false,\n        "allowHeaders": [],\n        "allowMethods": [],\n        "allowOrigin": "",\n        "enabled": false,\n        "excludedPatterns": [],\n        "exposeHeaders": [],\n        "maxAge": 0\n      },\n      "domain": "",\n      "enabled": false,\n      "enforceSecureCommunication": false,\n      "env": "",\n      "forceHttps": false,\n      "groups": [],\n      "gzip": {\n        "blackList": [],\n        "bufferSize": 0,\n        "chunkedThreshold": 0,\n        "compressionLevel": 0,\n        "enabled": false,\n        "excludedPatterns": [],\n        "whiteList": []\n      },\n      "headersVerification": {},\n      "healthCheck": {\n        "enabled": false,\n        "url": ""\n      },\n      "id": "",\n      "ipFiltering": {},\n      "jwtVerifier": "",\n      "localHost": "",\n      "localScheme": "",\n      "maintenanceMode": false,\n      "matchingHeaders": {},\n      "matchingRoot": "",\n      "metadata": {},\n      "name": "",\n      "overrideHost": false,\n      "privateApp": false,\n      "privatePatterns": [],\n      "publicPatterns": [],\n      "redirectToLocal": false,\n      "redirection": {\n        "code": 0,\n        "enabled": false,\n        "to": ""\n      },\n      "root": "",\n      "secComExcludedPatterns": [],\n      "secComSettings": "",\n      "sendOtoroshiHeadersBack": false,\n      "statsdConfig": {\n        "datadog": false,\n        "host": "",\n        "port": 0\n      },\n      "subdomain": "",\n      "targets": [\n        {}\n      ],\n      "transformerRef": "",\n      "userFacing": false,\n      "xForwardedHeaders": false\n    }\n  ],\n  "serviceGroups": [\n    {\n      "description": "",\n      "id": "",\n      "name": ""\n    }\n  ],\n  "simpleAdmins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "username": ""\n    }\n  ],\n  "stats": {\n    "calls": 0,\n    "dataIn": 0,\n    "dataOut": 0\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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/import")
  .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/api/import',
  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({
  admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
  apiKeys: [
    {
      authorizedEntities: [],
      clientId: '',
      clientName: '',
      clientSecret: '',
      dailyQuota: 0,
      enabled: false,
      metadata: {},
      monthlyQuota: 0,
      throttlingQuota: 0
    }
  ],
  appConfig: {},
  config: {
    alertsEmails: [],
    alertsWebhooks: [{headers: {}, url: ''}],
    analyticsWebhooks: [{}],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
    cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
    elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
    elasticWritesConfigs: [{}],
    endlessIpAddresses: [],
    ipFiltering: {blacklist: [], whitelist: []},
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  },
  date: '',
  dateRaw: 0,
  errorTemplates: [
    {
      messages: {},
      serviceId: '',
      template40x: '',
      template50x: '',
      templateBuild: '',
      templateMaintenance: ''
    }
  ],
  label: '',
  serviceDescriptors: [
    {
      Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
      additionalHeaders: {},
      api: {exposeApi: false, openApiDescriptorUrl: ''},
      authConfigRef: '',
      buildMode: false,
      chaosConfig: {
        badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
        enabled: false,
        largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
        largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
        latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
      },
      clientConfig: {
        backoffFactor: 0,
        callTimeout: 0,
        globalTimeout: 0,
        maxErrors: 0,
        retries: 0,
        retryInitialDelay: 0,
        sampleInterval: 0,
        useCircuitBreaker: false
      },
      clientValidatorRef: '',
      cors: {
        allowCredentials: false,
        allowHeaders: [],
        allowMethods: [],
        allowOrigin: '',
        enabled: false,
        excludedPatterns: [],
        exposeHeaders: [],
        maxAge: 0
      },
      domain: '',
      enabled: false,
      enforceSecureCommunication: false,
      env: '',
      forceHttps: false,
      groups: [],
      gzip: {
        blackList: [],
        bufferSize: 0,
        chunkedThreshold: 0,
        compressionLevel: 0,
        enabled: false,
        excludedPatterns: [],
        whiteList: []
      },
      headersVerification: {},
      healthCheck: {enabled: false, url: ''},
      id: '',
      ipFiltering: {},
      jwtVerifier: '',
      localHost: '',
      localScheme: '',
      maintenanceMode: false,
      matchingHeaders: {},
      matchingRoot: '',
      metadata: {},
      name: '',
      overrideHost: false,
      privateApp: false,
      privatePatterns: [],
      publicPatterns: [],
      redirectToLocal: false,
      redirection: {code: 0, enabled: false, to: ''},
      root: '',
      secComExcludedPatterns: [],
      secComSettings: '',
      sendOtoroshiHeadersBack: false,
      statsdConfig: {datadog: false, host: '', port: 0},
      subdomain: '',
      targets: [{}],
      transformerRef: '',
      userFacing: false,
      xForwardedHeaders: false
    }
  ],
  serviceGroups: [{description: '', id: '', name: ''}],
  simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
  stats: {calls: 0, dataIn: 0, dataOut: 0}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/import',
  headers: {'content-type': 'application/json'},
  body: {
    admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
    apiKeys: [
      {
        authorizedEntities: [],
        clientId: '',
        clientName: '',
        clientSecret: '',
        dailyQuota: 0,
        enabled: false,
        metadata: {},
        monthlyQuota: 0,
        throttlingQuota: 0
      }
    ],
    appConfig: {},
    config: {
      alertsEmails: [],
      alertsWebhooks: [{headers: {}, url: ''}],
      analyticsWebhooks: [{}],
      apiReadOnly: false,
      autoLinkToDefaultGroup: false,
      backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
      cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
      elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
      elasticWritesConfigs: [{}],
      endlessIpAddresses: [],
      ipFiltering: {blacklist: [], whitelist: []},
      limitConcurrentRequests: false,
      lines: [],
      mailerSettings: {
        apiKey: '',
        apiKeyPrivate: '',
        apiKeyPublic: '',
        domain: '',
        eu: false,
        header: {},
        type: '',
        url: ''
      },
      maxConcurrentRequests: 0,
      maxHttp10ResponseSize: 0,
      maxLogsSize: 0,
      middleFingers: false,
      perIpThrottlingQuota: 0,
      privateAppsAuth0Config: {},
      streamEntityOnly: false,
      throttlingQuota: 0,
      u2fLoginOnly: false,
      useCircuitBreakers: false
    },
    date: '',
    dateRaw: 0,
    errorTemplates: [
      {
        messages: {},
        serviceId: '',
        template40x: '',
        template50x: '',
        templateBuild: '',
        templateMaintenance: ''
      }
    ],
    label: '',
    serviceDescriptors: [
      {
        Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
        additionalHeaders: {},
        api: {exposeApi: false, openApiDescriptorUrl: ''},
        authConfigRef: '',
        buildMode: false,
        chaosConfig: {
          badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
          enabled: false,
          largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
          largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
          latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
        },
        clientConfig: {
          backoffFactor: 0,
          callTimeout: 0,
          globalTimeout: 0,
          maxErrors: 0,
          retries: 0,
          retryInitialDelay: 0,
          sampleInterval: 0,
          useCircuitBreaker: false
        },
        clientValidatorRef: '',
        cors: {
          allowCredentials: false,
          allowHeaders: [],
          allowMethods: [],
          allowOrigin: '',
          enabled: false,
          excludedPatterns: [],
          exposeHeaders: [],
          maxAge: 0
        },
        domain: '',
        enabled: false,
        enforceSecureCommunication: false,
        env: '',
        forceHttps: false,
        groups: [],
        gzip: {
          blackList: [],
          bufferSize: 0,
          chunkedThreshold: 0,
          compressionLevel: 0,
          enabled: false,
          excludedPatterns: [],
          whiteList: []
        },
        headersVerification: {},
        healthCheck: {enabled: false, url: ''},
        id: '',
        ipFiltering: {},
        jwtVerifier: '',
        localHost: '',
        localScheme: '',
        maintenanceMode: false,
        matchingHeaders: {},
        matchingRoot: '',
        metadata: {},
        name: '',
        overrideHost: false,
        privateApp: false,
        privatePatterns: [],
        publicPatterns: [],
        redirectToLocal: false,
        redirection: {code: 0, enabled: false, to: ''},
        root: '',
        secComExcludedPatterns: [],
        secComSettings: '',
        sendOtoroshiHeadersBack: false,
        statsdConfig: {datadog: false, host: '', port: 0},
        subdomain: '',
        targets: [{}],
        transformerRef: '',
        userFacing: false,
        xForwardedHeaders: false
      }
    ],
    serviceGroups: [{description: '', id: '', name: ''}],
    simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
    stats: {calls: 0, dataIn: 0, dataOut: 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}}/api/import');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  admins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      registration: {},
      username: ''
    }
  ],
  apiKeys: [
    {
      authorizedEntities: [],
      clientId: '',
      clientName: '',
      clientSecret: '',
      dailyQuota: 0,
      enabled: false,
      metadata: {},
      monthlyQuota: 0,
      throttlingQuota: 0
    }
  ],
  appConfig: {},
  config: {
    alertsEmails: [],
    alertsWebhooks: [
      {
        headers: {},
        url: ''
      }
    ],
    analyticsWebhooks: [
      {}
    ],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {
      callbackUrl: '',
      clientId: '',
      clientSecret: '',
      domain: ''
    },
    cleverSettings: {
      consumerKey: '',
      consumerSecret: '',
      orgaId: '',
      secret: '',
      token: ''
    },
    elasticReadsConfig: {
      clusterUri: '',
      headers: {},
      index: '',
      password: '',
      type: '',
      user: ''
    },
    elasticWritesConfigs: [
      {}
    ],
    endlessIpAddresses: [],
    ipFiltering: {
      blacklist: [],
      whitelist: []
    },
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  },
  date: '',
  dateRaw: 0,
  errorTemplates: [
    {
      messages: {},
      serviceId: '',
      template40x: '',
      template50x: '',
      templateBuild: '',
      templateMaintenance: ''
    }
  ],
  label: '',
  serviceDescriptors: [
    {
      Canary: {
        enabled: false,
        root: '',
        targets: [
          {
            host: '',
            scheme: ''
          }
        ],
        traffic: 0
      },
      additionalHeaders: {},
      api: {
        exposeApi: false,
        openApiDescriptorUrl: ''
      },
      authConfigRef: '',
      buildMode: false,
      chaosConfig: {
        badResponsesFaultConfig: {
          ratio: '',
          responses: [
            {
              body: '',
              headers: {},
              status: 0
            }
          ]
        },
        enabled: false,
        largeRequestFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        largeResponseFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        latencyInjectionFaultConfig: {
          from: 0,
          ratio: '',
          to: 0
        }
      },
      clientConfig: {
        backoffFactor: 0,
        callTimeout: 0,
        globalTimeout: 0,
        maxErrors: 0,
        retries: 0,
        retryInitialDelay: 0,
        sampleInterval: 0,
        useCircuitBreaker: false
      },
      clientValidatorRef: '',
      cors: {
        allowCredentials: false,
        allowHeaders: [],
        allowMethods: [],
        allowOrigin: '',
        enabled: false,
        excludedPatterns: [],
        exposeHeaders: [],
        maxAge: 0
      },
      domain: '',
      enabled: false,
      enforceSecureCommunication: false,
      env: '',
      forceHttps: false,
      groups: [],
      gzip: {
        blackList: [],
        bufferSize: 0,
        chunkedThreshold: 0,
        compressionLevel: 0,
        enabled: false,
        excludedPatterns: [],
        whiteList: []
      },
      headersVerification: {},
      healthCheck: {
        enabled: false,
        url: ''
      },
      id: '',
      ipFiltering: {},
      jwtVerifier: '',
      localHost: '',
      localScheme: '',
      maintenanceMode: false,
      matchingHeaders: {},
      matchingRoot: '',
      metadata: {},
      name: '',
      overrideHost: false,
      privateApp: false,
      privatePatterns: [],
      publicPatterns: [],
      redirectToLocal: false,
      redirection: {
        code: 0,
        enabled: false,
        to: ''
      },
      root: '',
      secComExcludedPatterns: [],
      secComSettings: '',
      sendOtoroshiHeadersBack: false,
      statsdConfig: {
        datadog: false,
        host: '',
        port: 0
      },
      subdomain: '',
      targets: [
        {}
      ],
      transformerRef: '',
      userFacing: false,
      xForwardedHeaders: false
    }
  ],
  serviceGroups: [
    {
      description: '',
      id: '',
      name: ''
    }
  ],
  simpleAdmins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      username: ''
    }
  ],
  stats: {
    calls: 0,
    dataIn: 0,
    dataOut: 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}}/api/import',
  headers: {'content-type': 'application/json'},
  data: {
    admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
    apiKeys: [
      {
        authorizedEntities: [],
        clientId: '',
        clientName: '',
        clientSecret: '',
        dailyQuota: 0,
        enabled: false,
        metadata: {},
        monthlyQuota: 0,
        throttlingQuota: 0
      }
    ],
    appConfig: {},
    config: {
      alertsEmails: [],
      alertsWebhooks: [{headers: {}, url: ''}],
      analyticsWebhooks: [{}],
      apiReadOnly: false,
      autoLinkToDefaultGroup: false,
      backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
      cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
      elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
      elasticWritesConfigs: [{}],
      endlessIpAddresses: [],
      ipFiltering: {blacklist: [], whitelist: []},
      limitConcurrentRequests: false,
      lines: [],
      mailerSettings: {
        apiKey: '',
        apiKeyPrivate: '',
        apiKeyPublic: '',
        domain: '',
        eu: false,
        header: {},
        type: '',
        url: ''
      },
      maxConcurrentRequests: 0,
      maxHttp10ResponseSize: 0,
      maxLogsSize: 0,
      middleFingers: false,
      perIpThrottlingQuota: 0,
      privateAppsAuth0Config: {},
      streamEntityOnly: false,
      throttlingQuota: 0,
      u2fLoginOnly: false,
      useCircuitBreakers: false
    },
    date: '',
    dateRaw: 0,
    errorTemplates: [
      {
        messages: {},
        serviceId: '',
        template40x: '',
        template50x: '',
        templateBuild: '',
        templateMaintenance: ''
      }
    ],
    label: '',
    serviceDescriptors: [
      {
        Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
        additionalHeaders: {},
        api: {exposeApi: false, openApiDescriptorUrl: ''},
        authConfigRef: '',
        buildMode: false,
        chaosConfig: {
          badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
          enabled: false,
          largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
          largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
          latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
        },
        clientConfig: {
          backoffFactor: 0,
          callTimeout: 0,
          globalTimeout: 0,
          maxErrors: 0,
          retries: 0,
          retryInitialDelay: 0,
          sampleInterval: 0,
          useCircuitBreaker: false
        },
        clientValidatorRef: '',
        cors: {
          allowCredentials: false,
          allowHeaders: [],
          allowMethods: [],
          allowOrigin: '',
          enabled: false,
          excludedPatterns: [],
          exposeHeaders: [],
          maxAge: 0
        },
        domain: '',
        enabled: false,
        enforceSecureCommunication: false,
        env: '',
        forceHttps: false,
        groups: [],
        gzip: {
          blackList: [],
          bufferSize: 0,
          chunkedThreshold: 0,
          compressionLevel: 0,
          enabled: false,
          excludedPatterns: [],
          whiteList: []
        },
        headersVerification: {},
        healthCheck: {enabled: false, url: ''},
        id: '',
        ipFiltering: {},
        jwtVerifier: '',
        localHost: '',
        localScheme: '',
        maintenanceMode: false,
        matchingHeaders: {},
        matchingRoot: '',
        metadata: {},
        name: '',
        overrideHost: false,
        privateApp: false,
        privatePatterns: [],
        publicPatterns: [],
        redirectToLocal: false,
        redirection: {code: 0, enabled: false, to: ''},
        root: '',
        secComExcludedPatterns: [],
        secComSettings: '',
        sendOtoroshiHeadersBack: false,
        statsdConfig: {datadog: false, host: '', port: 0},
        subdomain: '',
        targets: [{}],
        transformerRef: '',
        userFacing: false,
        xForwardedHeaders: false
      }
    ],
    serviceGroups: [{description: '', id: '', name: ''}],
    simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
    stats: {calls: 0, dataIn: 0, dataOut: 0}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"admins":[{"createdAt":0,"label":"","password":"","registration":{},"username":""}],"apiKeys":[{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":0}],"appConfig":{},"config":{"alertsEmails":[],"alertsWebhooks":[{"headers":{},"url":""}],"analyticsWebhooks":[{}],"apiReadOnly":false,"autoLinkToDefaultGroup":false,"backofficeAuth0Config":{"callbackUrl":"","clientId":"","clientSecret":"","domain":""},"cleverSettings":{"consumerKey":"","consumerSecret":"","orgaId":"","secret":"","token":""},"elasticReadsConfig":{"clusterUri":"","headers":{},"index":"","password":"","type":"","user":""},"elasticWritesConfigs":[{}],"endlessIpAddresses":[],"ipFiltering":{"blacklist":[],"whitelist":[]},"limitConcurrentRequests":false,"lines":[],"mailerSettings":{"apiKey":"","apiKeyPrivate":"","apiKeyPublic":"","domain":"","eu":false,"header":{},"type":"","url":""},"maxConcurrentRequests":0,"maxHttp10ResponseSize":0,"maxLogsSize":0,"middleFingers":false,"perIpThrottlingQuota":0,"privateAppsAuth0Config":{},"streamEntityOnly":false,"throttlingQuota":0,"u2fLoginOnly":false,"useCircuitBreakers":false},"date":"","dateRaw":0,"errorTemplates":[{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}],"label":"","serviceDescriptors":[{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}],"serviceGroups":[{"description":"","id":"","name":""}],"simpleAdmins":[{"createdAt":0,"label":"","password":"","username":""}],"stats":{"calls":0,"dataIn":0,"dataOut":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 = @{ @"admins": @[ @{ @"createdAt": @0, @"label": @"", @"password": @"", @"registration": @{  }, @"username": @"" } ],
                              @"apiKeys": @[ @{ @"authorizedEntities": @[  ], @"clientId": @"", @"clientName": @"", @"clientSecret": @"", @"dailyQuota": @0, @"enabled": @NO, @"metadata": @{  }, @"monthlyQuota": @0, @"throttlingQuota": @0 } ],
                              @"appConfig": @{  },
                              @"config": @{ @"alertsEmails": @[  ], @"alertsWebhooks": @[ @{ @"headers": @{  }, @"url": @"" } ], @"analyticsWebhooks": @[ @{  } ], @"apiReadOnly": @NO, @"autoLinkToDefaultGroup": @NO, @"backofficeAuth0Config": @{ @"callbackUrl": @"", @"clientId": @"", @"clientSecret": @"", @"domain": @"" }, @"cleverSettings": @{ @"consumerKey": @"", @"consumerSecret": @"", @"orgaId": @"", @"secret": @"", @"token": @"" }, @"elasticReadsConfig": @{ @"clusterUri": @"", @"headers": @{  }, @"index": @"", @"password": @"", @"type": @"", @"user": @"" }, @"elasticWritesConfigs": @[ @{  } ], @"endlessIpAddresses": @[  ], @"ipFiltering": @{ @"blacklist": @[  ], @"whitelist": @[  ] }, @"limitConcurrentRequests": @NO, @"lines": @[  ], @"mailerSettings": @{ @"apiKey": @"", @"apiKeyPrivate": @"", @"apiKeyPublic": @"", @"domain": @"", @"eu": @NO, @"header": @{  }, @"type": @"", @"url": @"" }, @"maxConcurrentRequests": @0, @"maxHttp10ResponseSize": @0, @"maxLogsSize": @0, @"middleFingers": @NO, @"perIpThrottlingQuota": @0, @"privateAppsAuth0Config": @{  }, @"streamEntityOnly": @NO, @"throttlingQuota": @0, @"u2fLoginOnly": @NO, @"useCircuitBreakers": @NO },
                              @"date": @"",
                              @"dateRaw": @0,
                              @"errorTemplates": @[ @{ @"messages": @{  }, @"serviceId": @"", @"template40x": @"", @"template50x": @"", @"templateBuild": @"", @"templateMaintenance": @"" } ],
                              @"label": @"",
                              @"serviceDescriptors": @[ @{ @"Canary": @{ @"enabled": @NO, @"root": @"", @"targets": @[ @{ @"host": @"", @"scheme": @"" } ], @"traffic": @0 }, @"additionalHeaders": @{  }, @"api": @{ @"exposeApi": @NO, @"openApiDescriptorUrl": @"" }, @"authConfigRef": @"", @"buildMode": @NO, @"chaosConfig": @{ @"badResponsesFaultConfig": @{ @"ratio": @"", @"responses": @[ @{ @"body": @"", @"headers": @{  }, @"status": @0 } ] }, @"enabled": @NO, @"largeRequestFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"largeResponseFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"latencyInjectionFaultConfig": @{ @"from": @0, @"ratio": @"", @"to": @0 } }, @"clientConfig": @{ @"backoffFactor": @0, @"callTimeout": @0, @"globalTimeout": @0, @"maxErrors": @0, @"retries": @0, @"retryInitialDelay": @0, @"sampleInterval": @0, @"useCircuitBreaker": @NO }, @"clientValidatorRef": @"", @"cors": @{ @"allowCredentials": @NO, @"allowHeaders": @[  ], @"allowMethods": @[  ], @"allowOrigin": @"", @"enabled": @NO, @"excludedPatterns": @[  ], @"exposeHeaders": @[  ], @"maxAge": @0 }, @"domain": @"", @"enabled": @NO, @"enforceSecureCommunication": @NO, @"env": @"", @"forceHttps": @NO, @"groups": @[  ], @"gzip": @{ @"blackList": @[  ], @"bufferSize": @0, @"chunkedThreshold": @0, @"compressionLevel": @0, @"enabled": @NO, @"excludedPatterns": @[  ], @"whiteList": @[  ] }, @"headersVerification": @{  }, @"healthCheck": @{ @"enabled": @NO, @"url": @"" }, @"id": @"", @"ipFiltering": @{  }, @"jwtVerifier": @"", @"localHost": @"", @"localScheme": @"", @"maintenanceMode": @NO, @"matchingHeaders": @{  }, @"matchingRoot": @"", @"metadata": @{  }, @"name": @"", @"overrideHost": @NO, @"privateApp": @NO, @"privatePatterns": @[  ], @"publicPatterns": @[  ], @"redirectToLocal": @NO, @"redirection": @{ @"code": @0, @"enabled": @NO, @"to": @"" }, @"root": @"", @"secComExcludedPatterns": @[  ], @"secComSettings": @"", @"sendOtoroshiHeadersBack": @NO, @"statsdConfig": @{ @"datadog": @NO, @"host": @"", @"port": @0 }, @"subdomain": @"", @"targets": @[ @{  } ], @"transformerRef": @"", @"userFacing": @NO, @"xForwardedHeaders": @NO } ],
                              @"serviceGroups": @[ @{ @"description": @"", @"id": @"", @"name": @"" } ],
                              @"simpleAdmins": @[ @{ @"createdAt": @0, @"label": @"", @"password": @"", @"username": @"" } ],
                              @"stats": @{ @"calls": @0, @"dataIn": @0, @"dataOut": @0 } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/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}}/api/import" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/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 => json_encode([
    'admins' => [
        [
                'createdAt' => 0,
                'label' => '',
                'password' => '',
                'registration' => [
                                
                ],
                'username' => ''
        ]
    ],
    'apiKeys' => [
        [
                'authorizedEntities' => [
                                
                ],
                'clientId' => '',
                'clientName' => '',
                'clientSecret' => '',
                'dailyQuota' => 0,
                'enabled' => null,
                'metadata' => [
                                
                ],
                'monthlyQuota' => 0,
                'throttlingQuota' => 0
        ]
    ],
    'appConfig' => [
        
    ],
    'config' => [
        'alertsEmails' => [
                
        ],
        'alertsWebhooks' => [
                [
                                'headers' => [
                                                                
                                ],
                                'url' => ''
                ]
        ],
        'analyticsWebhooks' => [
                [
                                
                ]
        ],
        'apiReadOnly' => null,
        'autoLinkToDefaultGroup' => null,
        'backofficeAuth0Config' => [
                'callbackUrl' => '',
                'clientId' => '',
                'clientSecret' => '',
                'domain' => ''
        ],
        'cleverSettings' => [
                'consumerKey' => '',
                'consumerSecret' => '',
                'orgaId' => '',
                'secret' => '',
                'token' => ''
        ],
        'elasticReadsConfig' => [
                'clusterUri' => '',
                'headers' => [
                                
                ],
                'index' => '',
                'password' => '',
                'type' => '',
                'user' => ''
        ],
        'elasticWritesConfigs' => [
                [
                                
                ]
        ],
        'endlessIpAddresses' => [
                
        ],
        'ipFiltering' => [
                'blacklist' => [
                                
                ],
                'whitelist' => [
                                
                ]
        ],
        'limitConcurrentRequests' => null,
        'lines' => [
                
        ],
        'mailerSettings' => [
                'apiKey' => '',
                'apiKeyPrivate' => '',
                'apiKeyPublic' => '',
                'domain' => '',
                'eu' => null,
                'header' => [
                                
                ],
                'type' => '',
                'url' => ''
        ],
        'maxConcurrentRequests' => 0,
        'maxHttp10ResponseSize' => 0,
        'maxLogsSize' => 0,
        'middleFingers' => null,
        'perIpThrottlingQuota' => 0,
        'privateAppsAuth0Config' => [
                
        ],
        'streamEntityOnly' => null,
        'throttlingQuota' => 0,
        'u2fLoginOnly' => null,
        'useCircuitBreakers' => null
    ],
    'date' => '',
    'dateRaw' => 0,
    'errorTemplates' => [
        [
                'messages' => [
                                
                ],
                'serviceId' => '',
                'template40x' => '',
                'template50x' => '',
                'templateBuild' => '',
                'templateMaintenance' => ''
        ]
    ],
    'label' => '',
    'serviceDescriptors' => [
        [
                'Canary' => [
                                'enabled' => null,
                                'root' => '',
                                'targets' => [
                                                                [
                                                                                                                                'host' => '',
                                                                                                                                'scheme' => ''
                                                                ]
                                ],
                                'traffic' => 0
                ],
                'additionalHeaders' => [
                                
                ],
                'api' => [
                                'exposeApi' => null,
                                'openApiDescriptorUrl' => ''
                ],
                'authConfigRef' => '',
                'buildMode' => null,
                'chaosConfig' => [
                                'badResponsesFaultConfig' => [
                                                                'ratio' => '',
                                                                'responses' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'body' => '',
                                                                                                                                                                                                                                                                'headers' => [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                ],
                                                                                                                                                                                                                                                                'status' => 0
                                                                                                                                ]
                                                                ]
                                ],
                                'enabled' => null,
                                'largeRequestFaultConfig' => [
                                                                'additionalRequestSize' => 0,
                                                                'ratio' => ''
                                ],
                                'largeResponseFaultConfig' => [
                                                                'additionalRequestSize' => 0,
                                                                'ratio' => ''
                                ],
                                'latencyInjectionFaultConfig' => [
                                                                'from' => 0,
                                                                'ratio' => '',
                                                                'to' => 0
                                ]
                ],
                'clientConfig' => [
                                'backoffFactor' => 0,
                                'callTimeout' => 0,
                                'globalTimeout' => 0,
                                'maxErrors' => 0,
                                'retries' => 0,
                                'retryInitialDelay' => 0,
                                'sampleInterval' => 0,
                                'useCircuitBreaker' => null
                ],
                'clientValidatorRef' => '',
                'cors' => [
                                'allowCredentials' => null,
                                'allowHeaders' => [
                                                                
                                ],
                                'allowMethods' => [
                                                                
                                ],
                                'allowOrigin' => '',
                                'enabled' => null,
                                'excludedPatterns' => [
                                                                
                                ],
                                'exposeHeaders' => [
                                                                
                                ],
                                'maxAge' => 0
                ],
                'domain' => '',
                'enabled' => null,
                'enforceSecureCommunication' => null,
                'env' => '',
                'forceHttps' => null,
                'groups' => [
                                
                ],
                'gzip' => [
                                'blackList' => [
                                                                
                                ],
                                'bufferSize' => 0,
                                'chunkedThreshold' => 0,
                                'compressionLevel' => 0,
                                'enabled' => null,
                                'excludedPatterns' => [
                                                                
                                ],
                                'whiteList' => [
                                                                
                                ]
                ],
                'headersVerification' => [
                                
                ],
                'healthCheck' => [
                                'enabled' => null,
                                'url' => ''
                ],
                'id' => '',
                'ipFiltering' => [
                                
                ],
                'jwtVerifier' => '',
                'localHost' => '',
                'localScheme' => '',
                'maintenanceMode' => null,
                'matchingHeaders' => [
                                
                ],
                'matchingRoot' => '',
                'metadata' => [
                                
                ],
                'name' => '',
                'overrideHost' => null,
                'privateApp' => null,
                'privatePatterns' => [
                                
                ],
                'publicPatterns' => [
                                
                ],
                'redirectToLocal' => null,
                'redirection' => [
                                'code' => 0,
                                'enabled' => null,
                                'to' => ''
                ],
                'root' => '',
                'secComExcludedPatterns' => [
                                
                ],
                'secComSettings' => '',
                'sendOtoroshiHeadersBack' => null,
                'statsdConfig' => [
                                'datadog' => null,
                                'host' => '',
                                'port' => 0
                ],
                'subdomain' => '',
                'targets' => [
                                [
                                                                
                                ]
                ],
                'transformerRef' => '',
                'userFacing' => null,
                'xForwardedHeaders' => null
        ]
    ],
    'serviceGroups' => [
        [
                'description' => '',
                'id' => '',
                'name' => ''
        ]
    ],
    'simpleAdmins' => [
        [
                'createdAt' => 0,
                'label' => '',
                'password' => '',
                'username' => ''
        ]
    ],
    'stats' => [
        'calls' => 0,
        'dataIn' => 0,
        'dataOut' => 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}}/api/import', [
  'body' => '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/import');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'admins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'registration' => [
                
        ],
        'username' => ''
    ]
  ],
  'apiKeys' => [
    [
        'authorizedEntities' => [
                
        ],
        'clientId' => '',
        'clientName' => '',
        'clientSecret' => '',
        'dailyQuota' => 0,
        'enabled' => null,
        'metadata' => [
                
        ],
        'monthlyQuota' => 0,
        'throttlingQuota' => 0
    ]
  ],
  'appConfig' => [
    
  ],
  'config' => [
    'alertsEmails' => [
        
    ],
    'alertsWebhooks' => [
        [
                'headers' => [
                                
                ],
                'url' => ''
        ]
    ],
    'analyticsWebhooks' => [
        [
                
        ]
    ],
    'apiReadOnly' => null,
    'autoLinkToDefaultGroup' => null,
    'backofficeAuth0Config' => [
        'callbackUrl' => '',
        'clientId' => '',
        'clientSecret' => '',
        'domain' => ''
    ],
    'cleverSettings' => [
        'consumerKey' => '',
        'consumerSecret' => '',
        'orgaId' => '',
        'secret' => '',
        'token' => ''
    ],
    'elasticReadsConfig' => [
        'clusterUri' => '',
        'headers' => [
                
        ],
        'index' => '',
        'password' => '',
        'type' => '',
        'user' => ''
    ],
    'elasticWritesConfigs' => [
        [
                
        ]
    ],
    'endlessIpAddresses' => [
        
    ],
    'ipFiltering' => [
        'blacklist' => [
                
        ],
        'whitelist' => [
                
        ]
    ],
    'limitConcurrentRequests' => null,
    'lines' => [
        
    ],
    'mailerSettings' => [
        'apiKey' => '',
        'apiKeyPrivate' => '',
        'apiKeyPublic' => '',
        'domain' => '',
        'eu' => null,
        'header' => [
                
        ],
        'type' => '',
        'url' => ''
    ],
    'maxConcurrentRequests' => 0,
    'maxHttp10ResponseSize' => 0,
    'maxLogsSize' => 0,
    'middleFingers' => null,
    'perIpThrottlingQuota' => 0,
    'privateAppsAuth0Config' => [
        
    ],
    'streamEntityOnly' => null,
    'throttlingQuota' => 0,
    'u2fLoginOnly' => null,
    'useCircuitBreakers' => null
  ],
  'date' => '',
  'dateRaw' => 0,
  'errorTemplates' => [
    [
        'messages' => [
                
        ],
        'serviceId' => '',
        'template40x' => '',
        'template50x' => '',
        'templateBuild' => '',
        'templateMaintenance' => ''
    ]
  ],
  'label' => '',
  'serviceDescriptors' => [
    [
        'Canary' => [
                'enabled' => null,
                'root' => '',
                'targets' => [
                                [
                                                                'host' => '',
                                                                'scheme' => ''
                                ]
                ],
                'traffic' => 0
        ],
        'additionalHeaders' => [
                
        ],
        'api' => [
                'exposeApi' => null,
                'openApiDescriptorUrl' => ''
        ],
        'authConfigRef' => '',
        'buildMode' => null,
        'chaosConfig' => [
                'badResponsesFaultConfig' => [
                                'ratio' => '',
                                'responses' => [
                                                                [
                                                                                                                                'body' => '',
                                                                                                                                'headers' => [
                                                                                                                                                                                                                                                                
                                                                                                                                ],
                                                                                                                                'status' => 0
                                                                ]
                                ]
                ],
                'enabled' => null,
                'largeRequestFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'largeResponseFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'latencyInjectionFaultConfig' => [
                                'from' => 0,
                                'ratio' => '',
                                'to' => 0
                ]
        ],
        'clientConfig' => [
                'backoffFactor' => 0,
                'callTimeout' => 0,
                'globalTimeout' => 0,
                'maxErrors' => 0,
                'retries' => 0,
                'retryInitialDelay' => 0,
                'sampleInterval' => 0,
                'useCircuitBreaker' => null
        ],
        'clientValidatorRef' => '',
        'cors' => [
                'allowCredentials' => null,
                'allowHeaders' => [
                                
                ],
                'allowMethods' => [
                                
                ],
                'allowOrigin' => '',
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'exposeHeaders' => [
                                
                ],
                'maxAge' => 0
        ],
        'domain' => '',
        'enabled' => null,
        'enforceSecureCommunication' => null,
        'env' => '',
        'forceHttps' => null,
        'groups' => [
                
        ],
        'gzip' => [
                'blackList' => [
                                
                ],
                'bufferSize' => 0,
                'chunkedThreshold' => 0,
                'compressionLevel' => 0,
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'whiteList' => [
                                
                ]
        ],
        'headersVerification' => [
                
        ],
        'healthCheck' => [
                'enabled' => null,
                'url' => ''
        ],
        'id' => '',
        'ipFiltering' => [
                
        ],
        'jwtVerifier' => '',
        'localHost' => '',
        'localScheme' => '',
        'maintenanceMode' => null,
        'matchingHeaders' => [
                
        ],
        'matchingRoot' => '',
        'metadata' => [
                
        ],
        'name' => '',
        'overrideHost' => null,
        'privateApp' => null,
        'privatePatterns' => [
                
        ],
        'publicPatterns' => [
                
        ],
        'redirectToLocal' => null,
        'redirection' => [
                'code' => 0,
                'enabled' => null,
                'to' => ''
        ],
        'root' => '',
        'secComExcludedPatterns' => [
                
        ],
        'secComSettings' => '',
        'sendOtoroshiHeadersBack' => null,
        'statsdConfig' => [
                'datadog' => null,
                'host' => '',
                'port' => 0
        ],
        'subdomain' => '',
        'targets' => [
                [
                                
                ]
        ],
        'transformerRef' => '',
        'userFacing' => null,
        'xForwardedHeaders' => null
    ]
  ],
  'serviceGroups' => [
    [
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ],
  'simpleAdmins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'username' => ''
    ]
  ],
  'stats' => [
    'calls' => 0,
    'dataIn' => 0,
    'dataOut' => 0
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'admins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'registration' => [
                
        ],
        'username' => ''
    ]
  ],
  'apiKeys' => [
    [
        'authorizedEntities' => [
                
        ],
        'clientId' => '',
        'clientName' => '',
        'clientSecret' => '',
        'dailyQuota' => 0,
        'enabled' => null,
        'metadata' => [
                
        ],
        'monthlyQuota' => 0,
        'throttlingQuota' => 0
    ]
  ],
  'appConfig' => [
    
  ],
  'config' => [
    'alertsEmails' => [
        
    ],
    'alertsWebhooks' => [
        [
                'headers' => [
                                
                ],
                'url' => ''
        ]
    ],
    'analyticsWebhooks' => [
        [
                
        ]
    ],
    'apiReadOnly' => null,
    'autoLinkToDefaultGroup' => null,
    'backofficeAuth0Config' => [
        'callbackUrl' => '',
        'clientId' => '',
        'clientSecret' => '',
        'domain' => ''
    ],
    'cleverSettings' => [
        'consumerKey' => '',
        'consumerSecret' => '',
        'orgaId' => '',
        'secret' => '',
        'token' => ''
    ],
    'elasticReadsConfig' => [
        'clusterUri' => '',
        'headers' => [
                
        ],
        'index' => '',
        'password' => '',
        'type' => '',
        'user' => ''
    ],
    'elasticWritesConfigs' => [
        [
                
        ]
    ],
    'endlessIpAddresses' => [
        
    ],
    'ipFiltering' => [
        'blacklist' => [
                
        ],
        'whitelist' => [
                
        ]
    ],
    'limitConcurrentRequests' => null,
    'lines' => [
        
    ],
    'mailerSettings' => [
        'apiKey' => '',
        'apiKeyPrivate' => '',
        'apiKeyPublic' => '',
        'domain' => '',
        'eu' => null,
        'header' => [
                
        ],
        'type' => '',
        'url' => ''
    ],
    'maxConcurrentRequests' => 0,
    'maxHttp10ResponseSize' => 0,
    'maxLogsSize' => 0,
    'middleFingers' => null,
    'perIpThrottlingQuota' => 0,
    'privateAppsAuth0Config' => [
        
    ],
    'streamEntityOnly' => null,
    'throttlingQuota' => 0,
    'u2fLoginOnly' => null,
    'useCircuitBreakers' => null
  ],
  'date' => '',
  'dateRaw' => 0,
  'errorTemplates' => [
    [
        'messages' => [
                
        ],
        'serviceId' => '',
        'template40x' => '',
        'template50x' => '',
        'templateBuild' => '',
        'templateMaintenance' => ''
    ]
  ],
  'label' => '',
  'serviceDescriptors' => [
    [
        'Canary' => [
                'enabled' => null,
                'root' => '',
                'targets' => [
                                [
                                                                'host' => '',
                                                                'scheme' => ''
                                ]
                ],
                'traffic' => 0
        ],
        'additionalHeaders' => [
                
        ],
        'api' => [
                'exposeApi' => null,
                'openApiDescriptorUrl' => ''
        ],
        'authConfigRef' => '',
        'buildMode' => null,
        'chaosConfig' => [
                'badResponsesFaultConfig' => [
                                'ratio' => '',
                                'responses' => [
                                                                [
                                                                                                                                'body' => '',
                                                                                                                                'headers' => [
                                                                                                                                                                                                                                                                
                                                                                                                                ],
                                                                                                                                'status' => 0
                                                                ]
                                ]
                ],
                'enabled' => null,
                'largeRequestFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'largeResponseFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'latencyInjectionFaultConfig' => [
                                'from' => 0,
                                'ratio' => '',
                                'to' => 0
                ]
        ],
        'clientConfig' => [
                'backoffFactor' => 0,
                'callTimeout' => 0,
                'globalTimeout' => 0,
                'maxErrors' => 0,
                'retries' => 0,
                'retryInitialDelay' => 0,
                'sampleInterval' => 0,
                'useCircuitBreaker' => null
        ],
        'clientValidatorRef' => '',
        'cors' => [
                'allowCredentials' => null,
                'allowHeaders' => [
                                
                ],
                'allowMethods' => [
                                
                ],
                'allowOrigin' => '',
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'exposeHeaders' => [
                                
                ],
                'maxAge' => 0
        ],
        'domain' => '',
        'enabled' => null,
        'enforceSecureCommunication' => null,
        'env' => '',
        'forceHttps' => null,
        'groups' => [
                
        ],
        'gzip' => [
                'blackList' => [
                                
                ],
                'bufferSize' => 0,
                'chunkedThreshold' => 0,
                'compressionLevel' => 0,
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'whiteList' => [
                                
                ]
        ],
        'headersVerification' => [
                
        ],
        'healthCheck' => [
                'enabled' => null,
                'url' => ''
        ],
        'id' => '',
        'ipFiltering' => [
                
        ],
        'jwtVerifier' => '',
        'localHost' => '',
        'localScheme' => '',
        'maintenanceMode' => null,
        'matchingHeaders' => [
                
        ],
        'matchingRoot' => '',
        'metadata' => [
                
        ],
        'name' => '',
        'overrideHost' => null,
        'privateApp' => null,
        'privatePatterns' => [
                
        ],
        'publicPatterns' => [
                
        ],
        'redirectToLocal' => null,
        'redirection' => [
                'code' => 0,
                'enabled' => null,
                'to' => ''
        ],
        'root' => '',
        'secComExcludedPatterns' => [
                
        ],
        'secComSettings' => '',
        'sendOtoroshiHeadersBack' => null,
        'statsdConfig' => [
                'datadog' => null,
                'host' => '',
                'port' => 0
        ],
        'subdomain' => '',
        'targets' => [
                [
                                
                ]
        ],
        'transformerRef' => '',
        'userFacing' => null,
        'xForwardedHeaders' => null
    ]
  ],
  'serviceGroups' => [
    [
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ],
  'simpleAdmins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'username' => ''
    ]
  ],
  'stats' => [
    'calls' => 0,
    'dataIn' => 0,
    'dataOut' => 0
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/import');
$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}}/api/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/import", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/import"

payload = {
    "admins": [
        {
            "createdAt": 0,
            "label": "",
            "password": "",
            "registration": {},
            "username": ""
        }
    ],
    "apiKeys": [
        {
            "authorizedEntities": [],
            "clientId": "",
            "clientName": "",
            "clientSecret": "",
            "dailyQuota": 0,
            "enabled": False,
            "metadata": {},
            "monthlyQuota": 0,
            "throttlingQuota": 0
        }
    ],
    "appConfig": {},
    "config": {
        "alertsEmails": [],
        "alertsWebhooks": [
            {
                "headers": {},
                "url": ""
            }
        ],
        "analyticsWebhooks": [{}],
        "apiReadOnly": False,
        "autoLinkToDefaultGroup": False,
        "backofficeAuth0Config": {
            "callbackUrl": "",
            "clientId": "",
            "clientSecret": "",
            "domain": ""
        },
        "cleverSettings": {
            "consumerKey": "",
            "consumerSecret": "",
            "orgaId": "",
            "secret": "",
            "token": ""
        },
        "elasticReadsConfig": {
            "clusterUri": "",
            "headers": {},
            "index": "",
            "password": "",
            "type": "",
            "user": ""
        },
        "elasticWritesConfigs": [{}],
        "endlessIpAddresses": [],
        "ipFiltering": {
            "blacklist": [],
            "whitelist": []
        },
        "limitConcurrentRequests": False,
        "lines": [],
        "mailerSettings": {
            "apiKey": "",
            "apiKeyPrivate": "",
            "apiKeyPublic": "",
            "domain": "",
            "eu": False,
            "header": {},
            "type": "",
            "url": ""
        },
        "maxConcurrentRequests": 0,
        "maxHttp10ResponseSize": 0,
        "maxLogsSize": 0,
        "middleFingers": False,
        "perIpThrottlingQuota": 0,
        "privateAppsAuth0Config": {},
        "streamEntityOnly": False,
        "throttlingQuota": 0,
        "u2fLoginOnly": False,
        "useCircuitBreakers": False
    },
    "date": "",
    "dateRaw": 0,
    "errorTemplates": [
        {
            "messages": {},
            "serviceId": "",
            "template40x": "",
            "template50x": "",
            "templateBuild": "",
            "templateMaintenance": ""
        }
    ],
    "label": "",
    "serviceDescriptors": [
        {
            "Canary": {
                "enabled": False,
                "root": "",
                "targets": [
                    {
                        "host": "",
                        "scheme": ""
                    }
                ],
                "traffic": 0
            },
            "additionalHeaders": {},
            "api": {
                "exposeApi": False,
                "openApiDescriptorUrl": ""
            },
            "authConfigRef": "",
            "buildMode": False,
            "chaosConfig": {
                "badResponsesFaultConfig": {
                    "ratio": "",
                    "responses": [
                        {
                            "body": "",
                            "headers": {},
                            "status": 0
                        }
                    ]
                },
                "enabled": False,
                "largeRequestFaultConfig": {
                    "additionalRequestSize": 0,
                    "ratio": ""
                },
                "largeResponseFaultConfig": {
                    "additionalRequestSize": 0,
                    "ratio": ""
                },
                "latencyInjectionFaultConfig": {
                    "from": 0,
                    "ratio": "",
                    "to": 0
                }
            },
            "clientConfig": {
                "backoffFactor": 0,
                "callTimeout": 0,
                "globalTimeout": 0,
                "maxErrors": 0,
                "retries": 0,
                "retryInitialDelay": 0,
                "sampleInterval": 0,
                "useCircuitBreaker": False
            },
            "clientValidatorRef": "",
            "cors": {
                "allowCredentials": False,
                "allowHeaders": [],
                "allowMethods": [],
                "allowOrigin": "",
                "enabled": False,
                "excludedPatterns": [],
                "exposeHeaders": [],
                "maxAge": 0
            },
            "domain": "",
            "enabled": False,
            "enforceSecureCommunication": False,
            "env": "",
            "forceHttps": False,
            "groups": [],
            "gzip": {
                "blackList": [],
                "bufferSize": 0,
                "chunkedThreshold": 0,
                "compressionLevel": 0,
                "enabled": False,
                "excludedPatterns": [],
                "whiteList": []
            },
            "headersVerification": {},
            "healthCheck": {
                "enabled": False,
                "url": ""
            },
            "id": "",
            "ipFiltering": {},
            "jwtVerifier": "",
            "localHost": "",
            "localScheme": "",
            "maintenanceMode": False,
            "matchingHeaders": {},
            "matchingRoot": "",
            "metadata": {},
            "name": "",
            "overrideHost": False,
            "privateApp": False,
            "privatePatterns": [],
            "publicPatterns": [],
            "redirectToLocal": False,
            "redirection": {
                "code": 0,
                "enabled": False,
                "to": ""
            },
            "root": "",
            "secComExcludedPatterns": [],
            "secComSettings": "",
            "sendOtoroshiHeadersBack": False,
            "statsdConfig": {
                "datadog": False,
                "host": "",
                "port": 0
            },
            "subdomain": "",
            "targets": [{}],
            "transformerRef": "",
            "userFacing": False,
            "xForwardedHeaders": False
        }
    ],
    "serviceGroups": [
        {
            "description": "",
            "id": "",
            "name": ""
        }
    ],
    "simpleAdmins": [
        {
            "createdAt": 0,
            "label": "",
            "password": "",
            "username": ""
        }
    ],
    "stats": {
        "calls": 0,
        "dataIn": 0,
        "dataOut": 0
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/import"

payload <- "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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}}/api/import")

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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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/api/import') do |req|
  req.body = "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/import";

    let payload = json!({
        "admins": (
            json!({
                "createdAt": 0,
                "label": "",
                "password": "",
                "registration": json!({}),
                "username": ""
            })
        ),
        "apiKeys": (
            json!({
                "authorizedEntities": (),
                "clientId": "",
                "clientName": "",
                "clientSecret": "",
                "dailyQuota": 0,
                "enabled": false,
                "metadata": json!({}),
                "monthlyQuota": 0,
                "throttlingQuota": 0
            })
        ),
        "appConfig": json!({}),
        "config": json!({
            "alertsEmails": (),
            "alertsWebhooks": (
                json!({
                    "headers": json!({}),
                    "url": ""
                })
            ),
            "analyticsWebhooks": (json!({})),
            "apiReadOnly": false,
            "autoLinkToDefaultGroup": false,
            "backofficeAuth0Config": json!({
                "callbackUrl": "",
                "clientId": "",
                "clientSecret": "",
                "domain": ""
            }),
            "cleverSettings": json!({
                "consumerKey": "",
                "consumerSecret": "",
                "orgaId": "",
                "secret": "",
                "token": ""
            }),
            "elasticReadsConfig": json!({
                "clusterUri": "",
                "headers": json!({}),
                "index": "",
                "password": "",
                "type": "",
                "user": ""
            }),
            "elasticWritesConfigs": (json!({})),
            "endlessIpAddresses": (),
            "ipFiltering": json!({
                "blacklist": (),
                "whitelist": ()
            }),
            "limitConcurrentRequests": false,
            "lines": (),
            "mailerSettings": json!({
                "apiKey": "",
                "apiKeyPrivate": "",
                "apiKeyPublic": "",
                "domain": "",
                "eu": false,
                "header": json!({}),
                "type": "",
                "url": ""
            }),
            "maxConcurrentRequests": 0,
            "maxHttp10ResponseSize": 0,
            "maxLogsSize": 0,
            "middleFingers": false,
            "perIpThrottlingQuota": 0,
            "privateAppsAuth0Config": json!({}),
            "streamEntityOnly": false,
            "throttlingQuota": 0,
            "u2fLoginOnly": false,
            "useCircuitBreakers": false
        }),
        "date": "",
        "dateRaw": 0,
        "errorTemplates": (
            json!({
                "messages": json!({}),
                "serviceId": "",
                "template40x": "",
                "template50x": "",
                "templateBuild": "",
                "templateMaintenance": ""
            })
        ),
        "label": "",
        "serviceDescriptors": (
            json!({
                "Canary": json!({
                    "enabled": false,
                    "root": "",
                    "targets": (
                        json!({
                            "host": "",
                            "scheme": ""
                        })
                    ),
                    "traffic": 0
                }),
                "additionalHeaders": json!({}),
                "api": json!({
                    "exposeApi": false,
                    "openApiDescriptorUrl": ""
                }),
                "authConfigRef": "",
                "buildMode": false,
                "chaosConfig": json!({
                    "badResponsesFaultConfig": json!({
                        "ratio": "",
                        "responses": (
                            json!({
                                "body": "",
                                "headers": json!({}),
                                "status": 0
                            })
                        )
                    }),
                    "enabled": false,
                    "largeRequestFaultConfig": json!({
                        "additionalRequestSize": 0,
                        "ratio": ""
                    }),
                    "largeResponseFaultConfig": json!({
                        "additionalRequestSize": 0,
                        "ratio": ""
                    }),
                    "latencyInjectionFaultConfig": json!({
                        "from": 0,
                        "ratio": "",
                        "to": 0
                    })
                }),
                "clientConfig": json!({
                    "backoffFactor": 0,
                    "callTimeout": 0,
                    "globalTimeout": 0,
                    "maxErrors": 0,
                    "retries": 0,
                    "retryInitialDelay": 0,
                    "sampleInterval": 0,
                    "useCircuitBreaker": false
                }),
                "clientValidatorRef": "",
                "cors": json!({
                    "allowCredentials": false,
                    "allowHeaders": (),
                    "allowMethods": (),
                    "allowOrigin": "",
                    "enabled": false,
                    "excludedPatterns": (),
                    "exposeHeaders": (),
                    "maxAge": 0
                }),
                "domain": "",
                "enabled": false,
                "enforceSecureCommunication": false,
                "env": "",
                "forceHttps": false,
                "groups": (),
                "gzip": json!({
                    "blackList": (),
                    "bufferSize": 0,
                    "chunkedThreshold": 0,
                    "compressionLevel": 0,
                    "enabled": false,
                    "excludedPatterns": (),
                    "whiteList": ()
                }),
                "headersVerification": json!({}),
                "healthCheck": json!({
                    "enabled": false,
                    "url": ""
                }),
                "id": "",
                "ipFiltering": json!({}),
                "jwtVerifier": "",
                "localHost": "",
                "localScheme": "",
                "maintenanceMode": false,
                "matchingHeaders": json!({}),
                "matchingRoot": "",
                "metadata": json!({}),
                "name": "",
                "overrideHost": false,
                "privateApp": false,
                "privatePatterns": (),
                "publicPatterns": (),
                "redirectToLocal": false,
                "redirection": json!({
                    "code": 0,
                    "enabled": false,
                    "to": ""
                }),
                "root": "",
                "secComExcludedPatterns": (),
                "secComSettings": "",
                "sendOtoroshiHeadersBack": false,
                "statsdConfig": json!({
                    "datadog": false,
                    "host": "",
                    "port": 0
                }),
                "subdomain": "",
                "targets": (json!({})),
                "transformerRef": "",
                "userFacing": false,
                "xForwardedHeaders": false
            })
        ),
        "serviceGroups": (
            json!({
                "description": "",
                "id": "",
                "name": ""
            })
        ),
        "simpleAdmins": (
            json!({
                "createdAt": 0,
                "label": "",
                "password": "",
                "username": ""
            })
        ),
        "stats": json!({
            "calls": 0,
            "dataIn": 0,
            "dataOut": 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}}/api/import \
  --header 'content-type: application/json' \
  --data '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}'

echo '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}' |  \
  http POST {{baseUrl}}/api/import \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "admins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "registration": {},\n      "username": ""\n    }\n  ],\n  "apiKeys": [\n    {\n      "authorizedEntities": [],\n      "clientId": "",\n      "clientName": "",\n      "clientSecret": "",\n      "dailyQuota": 0,\n      "enabled": false,\n      "metadata": {},\n      "monthlyQuota": 0,\n      "throttlingQuota": 0\n    }\n  ],\n  "appConfig": {},\n  "config": {\n    "alertsEmails": [],\n    "alertsWebhooks": [\n      {\n        "headers": {},\n        "url": ""\n      }\n    ],\n    "analyticsWebhooks": [\n      {}\n    ],\n    "apiReadOnly": false,\n    "autoLinkToDefaultGroup": false,\n    "backofficeAuth0Config": {\n      "callbackUrl": "",\n      "clientId": "",\n      "clientSecret": "",\n      "domain": ""\n    },\n    "cleverSettings": {\n      "consumerKey": "",\n      "consumerSecret": "",\n      "orgaId": "",\n      "secret": "",\n      "token": ""\n    },\n    "elasticReadsConfig": {\n      "clusterUri": "",\n      "headers": {},\n      "index": "",\n      "password": "",\n      "type": "",\n      "user": ""\n    },\n    "elasticWritesConfigs": [\n      {}\n    ],\n    "endlessIpAddresses": [],\n    "ipFiltering": {\n      "blacklist": [],\n      "whitelist": []\n    },\n    "limitConcurrentRequests": false,\n    "lines": [],\n    "mailerSettings": {\n      "apiKey": "",\n      "apiKeyPrivate": "",\n      "apiKeyPublic": "",\n      "domain": "",\n      "eu": false,\n      "header": {},\n      "type": "",\n      "url": ""\n    },\n    "maxConcurrentRequests": 0,\n    "maxHttp10ResponseSize": 0,\n    "maxLogsSize": 0,\n    "middleFingers": false,\n    "perIpThrottlingQuota": 0,\n    "privateAppsAuth0Config": {},\n    "streamEntityOnly": false,\n    "throttlingQuota": 0,\n    "u2fLoginOnly": false,\n    "useCircuitBreakers": false\n  },\n  "date": "",\n  "dateRaw": 0,\n  "errorTemplates": [\n    {\n      "messages": {},\n      "serviceId": "",\n      "template40x": "",\n      "template50x": "",\n      "templateBuild": "",\n      "templateMaintenance": ""\n    }\n  ],\n  "label": "",\n  "serviceDescriptors": [\n    {\n      "Canary": {\n        "enabled": false,\n        "root": "",\n        "targets": [\n          {\n            "host": "",\n            "scheme": ""\n          }\n        ],\n        "traffic": 0\n      },\n      "additionalHeaders": {},\n      "api": {\n        "exposeApi": false,\n        "openApiDescriptorUrl": ""\n      },\n      "authConfigRef": "",\n      "buildMode": false,\n      "chaosConfig": {\n        "badResponsesFaultConfig": {\n          "ratio": "",\n          "responses": [\n            {\n              "body": "",\n              "headers": {},\n              "status": 0\n            }\n          ]\n        },\n        "enabled": false,\n        "largeRequestFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "largeResponseFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "latencyInjectionFaultConfig": {\n          "from": 0,\n          "ratio": "",\n          "to": 0\n        }\n      },\n      "clientConfig": {\n        "backoffFactor": 0,\n        "callTimeout": 0,\n        "globalTimeout": 0,\n        "maxErrors": 0,\n        "retries": 0,\n        "retryInitialDelay": 0,\n        "sampleInterval": 0,\n        "useCircuitBreaker": false\n      },\n      "clientValidatorRef": "",\n      "cors": {\n        "allowCredentials": false,\n        "allowHeaders": [],\n        "allowMethods": [],\n        "allowOrigin": "",\n        "enabled": false,\n        "excludedPatterns": [],\n        "exposeHeaders": [],\n        "maxAge": 0\n      },\n      "domain": "",\n      "enabled": false,\n      "enforceSecureCommunication": false,\n      "env": "",\n      "forceHttps": false,\n      "groups": [],\n      "gzip": {\n        "blackList": [],\n        "bufferSize": 0,\n        "chunkedThreshold": 0,\n        "compressionLevel": 0,\n        "enabled": false,\n        "excludedPatterns": [],\n        "whiteList": []\n      },\n      "headersVerification": {},\n      "healthCheck": {\n        "enabled": false,\n        "url": ""\n      },\n      "id": "",\n      "ipFiltering": {},\n      "jwtVerifier": "",\n      "localHost": "",\n      "localScheme": "",\n      "maintenanceMode": false,\n      "matchingHeaders": {},\n      "matchingRoot": "",\n      "metadata": {},\n      "name": "",\n      "overrideHost": false,\n      "privateApp": false,\n      "privatePatterns": [],\n      "publicPatterns": [],\n      "redirectToLocal": false,\n      "redirection": {\n        "code": 0,\n        "enabled": false,\n        "to": ""\n      },\n      "root": "",\n      "secComExcludedPatterns": [],\n      "secComSettings": "",\n      "sendOtoroshiHeadersBack": false,\n      "statsdConfig": {\n        "datadog": false,\n        "host": "",\n        "port": 0\n      },\n      "subdomain": "",\n      "targets": [\n        {}\n      ],\n      "transformerRef": "",\n      "userFacing": false,\n      "xForwardedHeaders": false\n    }\n  ],\n  "serviceGroups": [\n    {\n      "description": "",\n      "id": "",\n      "name": ""\n    }\n  ],\n  "simpleAdmins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "username": ""\n    }\n  ],\n  "stats": {\n    "calls": 0,\n    "dataIn": 0,\n    "dataOut": 0\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/import

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "admins": [
    [
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": [],
      "username": ""
    ]
  ],
  "apiKeys": [
    [
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": [],
      "monthlyQuota": 0,
      "throttlingQuota": 0
    ]
  ],
  "appConfig": [],
  "config": [
    "alertsEmails": [],
    "alertsWebhooks": [
      [
        "headers": [],
        "url": ""
      ]
    ],
    "analyticsWebhooks": [[]],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": [
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    ],
    "cleverSettings": [
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    ],
    "elasticReadsConfig": [
      "clusterUri": "",
      "headers": [],
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    ],
    "elasticWritesConfigs": [[]],
    "endlessIpAddresses": [],
    "ipFiltering": [
      "blacklist": [],
      "whitelist": []
    ],
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": [
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": [],
      "type": "",
      "url": ""
    ],
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": [],
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  ],
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    [
      "messages": [],
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    ]
  ],
  "label": "",
  "serviceDescriptors": [
    [
      "Canary": [
        "enabled": false,
        "root": "",
        "targets": [
          [
            "host": "",
            "scheme": ""
          ]
        ],
        "traffic": 0
      ],
      "additionalHeaders": [],
      "api": [
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      ],
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": [
        "badResponsesFaultConfig": [
          "ratio": "",
          "responses": [
            [
              "body": "",
              "headers": [],
              "status": 0
            ]
          ]
        ],
        "enabled": false,
        "largeRequestFaultConfig": [
          "additionalRequestSize": 0,
          "ratio": ""
        ],
        "largeResponseFaultConfig": [
          "additionalRequestSize": 0,
          "ratio": ""
        ],
        "latencyInjectionFaultConfig": [
          "from": 0,
          "ratio": "",
          "to": 0
        ]
      ],
      "clientConfig": [
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      ],
      "clientValidatorRef": "",
      "cors": [
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      ],
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": [
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      ],
      "headersVerification": [],
      "healthCheck": [
        "enabled": false,
        "url": ""
      ],
      "id": "",
      "ipFiltering": [],
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": [],
      "matchingRoot": "",
      "metadata": [],
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": [
        "code": 0,
        "enabled": false,
        "to": ""
      ],
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": [
        "datadog": false,
        "host": "",
        "port": 0
      ],
      "subdomain": "",
      "targets": [[]],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    ]
  ],
  "serviceGroups": [
    [
      "description": "",
      "id": "",
      "name": ""
    ]
  ],
  "simpleAdmins": [
    [
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    ]
  ],
  "stats": [
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "done": true
}

POST Import the full state of Otoroshi

{{baseUrl}}/api/otoroshi.json

BODY json

{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/otoroshi.json");

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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/otoroshi.json" {:content-type :json
                                                              :form-params {:admins [{:createdAt 0
                                                                                      :label ""
                                                                                      :password ""
                                                                                      :registration {}
                                                                                      :username ""}]
                                                                            :apiKeys [{:authorizedEntities []
                                                                                       :clientId ""
                                                                                       :clientName ""
                                                                                       :clientSecret ""
                                                                                       :dailyQuota 0
                                                                                       :enabled false
                                                                                       :metadata {}
                                                                                       :monthlyQuota 0
                                                                                       :throttlingQuota 0}]
                                                                            :appConfig {}
                                                                            :config {:alertsEmails []
                                                                                     :alertsWebhooks [{:headers {}
                                                                                                       :url ""}]
                                                                                     :analyticsWebhooks [{}]
                                                                                     :apiReadOnly false
                                                                                     :autoLinkToDefaultGroup false
                                                                                     :backofficeAuth0Config {:callbackUrl ""
                                                                                                             :clientId ""
                                                                                                             :clientSecret ""
                                                                                                             :domain ""}
                                                                                     :cleverSettings {:consumerKey ""
                                                                                                      :consumerSecret ""
                                                                                                      :orgaId ""
                                                                                                      :secret ""
                                                                                                      :token ""}
                                                                                     :elasticReadsConfig {:clusterUri ""
                                                                                                          :headers {}
                                                                                                          :index ""
                                                                                                          :password ""
                                                                                                          :type ""
                                                                                                          :user ""}
                                                                                     :elasticWritesConfigs [{}]
                                                                                     :endlessIpAddresses []
                                                                                     :ipFiltering {:blacklist []
                                                                                                   :whitelist []}
                                                                                     :limitConcurrentRequests false
                                                                                     :lines []
                                                                                     :mailerSettings {:apiKey ""
                                                                                                      :apiKeyPrivate ""
                                                                                                      :apiKeyPublic ""
                                                                                                      :domain ""
                                                                                                      :eu false
                                                                                                      :header {}
                                                                                                      :type ""
                                                                                                      :url ""}
                                                                                     :maxConcurrentRequests 0
                                                                                     :maxHttp10ResponseSize 0
                                                                                     :maxLogsSize 0
                                                                                     :middleFingers false
                                                                                     :perIpThrottlingQuota 0
                                                                                     :privateAppsAuth0Config {}
                                                                                     :streamEntityOnly false
                                                                                     :throttlingQuota 0
                                                                                     :u2fLoginOnly false
                                                                                     :useCircuitBreakers false}
                                                                            :date ""
                                                                            :dateRaw 0
                                                                            :errorTemplates [{:messages {}
                                                                                              :serviceId ""
                                                                                              :template40x ""
                                                                                              :template50x ""
                                                                                              :templateBuild ""
                                                                                              :templateMaintenance ""}]
                                                                            :label ""
                                                                            :serviceDescriptors [{:Canary {:enabled false
                                                                                                           :root ""
                                                                                                           :targets [{:host ""
                                                                                                                      :scheme ""}]
                                                                                                           :traffic 0}
                                                                                                  :additionalHeaders {}
                                                                                                  :api {:exposeApi false
                                                                                                        :openApiDescriptorUrl ""}
                                                                                                  :authConfigRef ""
                                                                                                  :buildMode false
                                                                                                  :chaosConfig {:badResponsesFaultConfig {:ratio ""
                                                                                                                                          :responses [{:body ""
                                                                                                                                                       :headers {}
                                                                                                                                                       :status 0}]}
                                                                                                                :enabled false
                                                                                                                :largeRequestFaultConfig {:additionalRequestSize 0
                                                                                                                                          :ratio ""}
                                                                                                                :largeResponseFaultConfig {:additionalRequestSize 0
                                                                                                                                           :ratio ""}
                                                                                                                :latencyInjectionFaultConfig {:from 0
                                                                                                                                              :ratio ""
                                                                                                                                              :to 0}}
                                                                                                  :clientConfig {:backoffFactor 0
                                                                                                                 :callTimeout 0
                                                                                                                 :globalTimeout 0
                                                                                                                 :maxErrors 0
                                                                                                                 :retries 0
                                                                                                                 :retryInitialDelay 0
                                                                                                                 :sampleInterval 0
                                                                                                                 :useCircuitBreaker false}
                                                                                                  :clientValidatorRef ""
                                                                                                  :cors {:allowCredentials false
                                                                                                         :allowHeaders []
                                                                                                         :allowMethods []
                                                                                                         :allowOrigin ""
                                                                                                         :enabled false
                                                                                                         :excludedPatterns []
                                                                                                         :exposeHeaders []
                                                                                                         :maxAge 0}
                                                                                                  :domain ""
                                                                                                  :enabled false
                                                                                                  :enforceSecureCommunication false
                                                                                                  :env ""
                                                                                                  :forceHttps false
                                                                                                  :groups []
                                                                                                  :gzip {:blackList []
                                                                                                         :bufferSize 0
                                                                                                         :chunkedThreshold 0
                                                                                                         :compressionLevel 0
                                                                                                         :enabled false
                                                                                                         :excludedPatterns []
                                                                                                         :whiteList []}
                                                                                                  :headersVerification {}
                                                                                                  :healthCheck {:enabled false
                                                                                                                :url ""}
                                                                                                  :id ""
                                                                                                  :ipFiltering {}
                                                                                                  :jwtVerifier ""
                                                                                                  :localHost ""
                                                                                                  :localScheme ""
                                                                                                  :maintenanceMode false
                                                                                                  :matchingHeaders {}
                                                                                                  :matchingRoot ""
                                                                                                  :metadata {}
                                                                                                  :name ""
                                                                                                  :overrideHost false
                                                                                                  :privateApp false
                                                                                                  :privatePatterns []
                                                                                                  :publicPatterns []
                                                                                                  :redirectToLocal false
                                                                                                  :redirection {:code 0
                                                                                                                :enabled false
                                                                                                                :to ""}
                                                                                                  :root ""
                                                                                                  :secComExcludedPatterns []
                                                                                                  :secComSettings ""
                                                                                                  :sendOtoroshiHeadersBack false
                                                                                                  :statsdConfig {:datadog false
                                                                                                                 :host ""
                                                                                                                 :port 0}
                                                                                                  :subdomain ""
                                                                                                  :targets [{}]
                                                                                                  :transformerRef ""
                                                                                                  :userFacing false
                                                                                                  :xForwardedHeaders false}]
                                                                            :serviceGroups [{:description ""
                                                                                             :id ""
                                                                                             :name ""}]
                                                                            :simpleAdmins [{:createdAt 0
                                                                                            :label ""
                                                                                            :password ""
                                                                                            :username ""}]
                                                                            :stats {:calls 0
                                                                                    :dataIn 0
                                                                                    :dataOut 0}}})

require "http/client"

url = "{{baseUrl}}/api/otoroshi.json"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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}}/api/otoroshi.json"),
    Content = new StringContent("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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}}/api/otoroshi.json");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/otoroshi.json"

	payload := strings.NewReader("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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/api/otoroshi.json HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 5188

{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/otoroshi.json")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/otoroshi.json"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/otoroshi.json")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/otoroshi.json")
  .header("content-type", "application/json")
  .body("{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}")
  .asString();

const data = JSON.stringify({
  admins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      registration: {},
      username: ''
    }
  ],
  apiKeys: [
    {
      authorizedEntities: [],
      clientId: '',
      clientName: '',
      clientSecret: '',
      dailyQuota: 0,
      enabled: false,
      metadata: {},
      monthlyQuota: 0,
      throttlingQuota: 0
    }
  ],
  appConfig: {},
  config: {
    alertsEmails: [],
    alertsWebhooks: [
      {
        headers: {},
        url: ''
      }
    ],
    analyticsWebhooks: [
      {}
    ],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {
      callbackUrl: '',
      clientId: '',
      clientSecret: '',
      domain: ''
    },
    cleverSettings: {
      consumerKey: '',
      consumerSecret: '',
      orgaId: '',
      secret: '',
      token: ''
    },
    elasticReadsConfig: {
      clusterUri: '',
      headers: {},
      index: '',
      password: '',
      type: '',
      user: ''
    },
    elasticWritesConfigs: [
      {}
    ],
    endlessIpAddresses: [],
    ipFiltering: {
      blacklist: [],
      whitelist: []
    },
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  },
  date: '',
  dateRaw: 0,
  errorTemplates: [
    {
      messages: {},
      serviceId: '',
      template40x: '',
      template50x: '',
      templateBuild: '',
      templateMaintenance: ''
    }
  ],
  label: '',
  serviceDescriptors: [
    {
      Canary: {
        enabled: false,
        root: '',
        targets: [
          {
            host: '',
            scheme: ''
          }
        ],
        traffic: 0
      },
      additionalHeaders: {},
      api: {
        exposeApi: false,
        openApiDescriptorUrl: ''
      },
      authConfigRef: '',
      buildMode: false,
      chaosConfig: {
        badResponsesFaultConfig: {
          ratio: '',
          responses: [
            {
              body: '',
              headers: {},
              status: 0
            }
          ]
        },
        enabled: false,
        largeRequestFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        largeResponseFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        latencyInjectionFaultConfig: {
          from: 0,
          ratio: '',
          to: 0
        }
      },
      clientConfig: {
        backoffFactor: 0,
        callTimeout: 0,
        globalTimeout: 0,
        maxErrors: 0,
        retries: 0,
        retryInitialDelay: 0,
        sampleInterval: 0,
        useCircuitBreaker: false
      },
      clientValidatorRef: '',
      cors: {
        allowCredentials: false,
        allowHeaders: [],
        allowMethods: [],
        allowOrigin: '',
        enabled: false,
        excludedPatterns: [],
        exposeHeaders: [],
        maxAge: 0
      },
      domain: '',
      enabled: false,
      enforceSecureCommunication: false,
      env: '',
      forceHttps: false,
      groups: [],
      gzip: {
        blackList: [],
        bufferSize: 0,
        chunkedThreshold: 0,
        compressionLevel: 0,
        enabled: false,
        excludedPatterns: [],
        whiteList: []
      },
      headersVerification: {},
      healthCheck: {
        enabled: false,
        url: ''
      },
      id: '',
      ipFiltering: {},
      jwtVerifier: '',
      localHost: '',
      localScheme: '',
      maintenanceMode: false,
      matchingHeaders: {},
      matchingRoot: '',
      metadata: {},
      name: '',
      overrideHost: false,
      privateApp: false,
      privatePatterns: [],
      publicPatterns: [],
      redirectToLocal: false,
      redirection: {
        code: 0,
        enabled: false,
        to: ''
      },
      root: '',
      secComExcludedPatterns: [],
      secComSettings: '',
      sendOtoroshiHeadersBack: false,
      statsdConfig: {
        datadog: false,
        host: '',
        port: 0
      },
      subdomain: '',
      targets: [
        {}
      ],
      transformerRef: '',
      userFacing: false,
      xForwardedHeaders: false
    }
  ],
  serviceGroups: [
    {
      description: '',
      id: '',
      name: ''
    }
  ],
  simpleAdmins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      username: ''
    }
  ],
  stats: {
    calls: 0,
    dataIn: 0,
    dataOut: 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}}/api/otoroshi.json');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/otoroshi.json',
  headers: {'content-type': 'application/json'},
  data: {
    admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
    apiKeys: [
      {
        authorizedEntities: [],
        clientId: '',
        clientName: '',
        clientSecret: '',
        dailyQuota: 0,
        enabled: false,
        metadata: {},
        monthlyQuota: 0,
        throttlingQuota: 0
      }
    ],
    appConfig: {},
    config: {
      alertsEmails: [],
      alertsWebhooks: [{headers: {}, url: ''}],
      analyticsWebhooks: [{}],
      apiReadOnly: false,
      autoLinkToDefaultGroup: false,
      backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
      cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
      elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
      elasticWritesConfigs: [{}],
      endlessIpAddresses: [],
      ipFiltering: {blacklist: [], whitelist: []},
      limitConcurrentRequests: false,
      lines: [],
      mailerSettings: {
        apiKey: '',
        apiKeyPrivate: '',
        apiKeyPublic: '',
        domain: '',
        eu: false,
        header: {},
        type: '',
        url: ''
      },
      maxConcurrentRequests: 0,
      maxHttp10ResponseSize: 0,
      maxLogsSize: 0,
      middleFingers: false,
      perIpThrottlingQuota: 0,
      privateAppsAuth0Config: {},
      streamEntityOnly: false,
      throttlingQuota: 0,
      u2fLoginOnly: false,
      useCircuitBreakers: false
    },
    date: '',
    dateRaw: 0,
    errorTemplates: [
      {
        messages: {},
        serviceId: '',
        template40x: '',
        template50x: '',
        templateBuild: '',
        templateMaintenance: ''
      }
    ],
    label: '',
    serviceDescriptors: [
      {
        Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
        additionalHeaders: {},
        api: {exposeApi: false, openApiDescriptorUrl: ''},
        authConfigRef: '',
        buildMode: false,
        chaosConfig: {
          badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
          enabled: false,
          largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
          largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
          latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
        },
        clientConfig: {
          backoffFactor: 0,
          callTimeout: 0,
          globalTimeout: 0,
          maxErrors: 0,
          retries: 0,
          retryInitialDelay: 0,
          sampleInterval: 0,
          useCircuitBreaker: false
        },
        clientValidatorRef: '',
        cors: {
          allowCredentials: false,
          allowHeaders: [],
          allowMethods: [],
          allowOrigin: '',
          enabled: false,
          excludedPatterns: [],
          exposeHeaders: [],
          maxAge: 0
        },
        domain: '',
        enabled: false,
        enforceSecureCommunication: false,
        env: '',
        forceHttps: false,
        groups: [],
        gzip: {
          blackList: [],
          bufferSize: 0,
          chunkedThreshold: 0,
          compressionLevel: 0,
          enabled: false,
          excludedPatterns: [],
          whiteList: []
        },
        headersVerification: {},
        healthCheck: {enabled: false, url: ''},
        id: '',
        ipFiltering: {},
        jwtVerifier: '',
        localHost: '',
        localScheme: '',
        maintenanceMode: false,
        matchingHeaders: {},
        matchingRoot: '',
        metadata: {},
        name: '',
        overrideHost: false,
        privateApp: false,
        privatePatterns: [],
        publicPatterns: [],
        redirectToLocal: false,
        redirection: {code: 0, enabled: false, to: ''},
        root: '',
        secComExcludedPatterns: [],
        secComSettings: '',
        sendOtoroshiHeadersBack: false,
        statsdConfig: {datadog: false, host: '', port: 0},
        subdomain: '',
        targets: [{}],
        transformerRef: '',
        userFacing: false,
        xForwardedHeaders: false
      }
    ],
    serviceGroups: [{description: '', id: '', name: ''}],
    simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
    stats: {calls: 0, dataIn: 0, dataOut: 0}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/otoroshi.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"admins":[{"createdAt":0,"label":"","password":"","registration":{},"username":""}],"apiKeys":[{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":0}],"appConfig":{},"config":{"alertsEmails":[],"alertsWebhooks":[{"headers":{},"url":""}],"analyticsWebhooks":[{}],"apiReadOnly":false,"autoLinkToDefaultGroup":false,"backofficeAuth0Config":{"callbackUrl":"","clientId":"","clientSecret":"","domain":""},"cleverSettings":{"consumerKey":"","consumerSecret":"","orgaId":"","secret":"","token":""},"elasticReadsConfig":{"clusterUri":"","headers":{},"index":"","password":"","type":"","user":""},"elasticWritesConfigs":[{}],"endlessIpAddresses":[],"ipFiltering":{"blacklist":[],"whitelist":[]},"limitConcurrentRequests":false,"lines":[],"mailerSettings":{"apiKey":"","apiKeyPrivate":"","apiKeyPublic":"","domain":"","eu":false,"header":{},"type":"","url":""},"maxConcurrentRequests":0,"maxHttp10ResponseSize":0,"maxLogsSize":0,"middleFingers":false,"perIpThrottlingQuota":0,"privateAppsAuth0Config":{},"streamEntityOnly":false,"throttlingQuota":0,"u2fLoginOnly":false,"useCircuitBreakers":false},"date":"","dateRaw":0,"errorTemplates":[{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}],"label":"","serviceDescriptors":[{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}],"serviceGroups":[{"description":"","id":"","name":""}],"simpleAdmins":[{"createdAt":0,"label":"","password":"","username":""}],"stats":{"calls":0,"dataIn":0,"dataOut":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}}/api/otoroshi.json',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "admins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "registration": {},\n      "username": ""\n    }\n  ],\n  "apiKeys": [\n    {\n      "authorizedEntities": [],\n      "clientId": "",\n      "clientName": "",\n      "clientSecret": "",\n      "dailyQuota": 0,\n      "enabled": false,\n      "metadata": {},\n      "monthlyQuota": 0,\n      "throttlingQuota": 0\n    }\n  ],\n  "appConfig": {},\n  "config": {\n    "alertsEmails": [],\n    "alertsWebhooks": [\n      {\n        "headers": {},\n        "url": ""\n      }\n    ],\n    "analyticsWebhooks": [\n      {}\n    ],\n    "apiReadOnly": false,\n    "autoLinkToDefaultGroup": false,\n    "backofficeAuth0Config": {\n      "callbackUrl": "",\n      "clientId": "",\n      "clientSecret": "",\n      "domain": ""\n    },\n    "cleverSettings": {\n      "consumerKey": "",\n      "consumerSecret": "",\n      "orgaId": "",\n      "secret": "",\n      "token": ""\n    },\n    "elasticReadsConfig": {\n      "clusterUri": "",\n      "headers": {},\n      "index": "",\n      "password": "",\n      "type": "",\n      "user": ""\n    },\n    "elasticWritesConfigs": [\n      {}\n    ],\n    "endlessIpAddresses": [],\n    "ipFiltering": {\n      "blacklist": [],\n      "whitelist": []\n    },\n    "limitConcurrentRequests": false,\n    "lines": [],\n    "mailerSettings": {\n      "apiKey": "",\n      "apiKeyPrivate": "",\n      "apiKeyPublic": "",\n      "domain": "",\n      "eu": false,\n      "header": {},\n      "type": "",\n      "url": ""\n    },\n    "maxConcurrentRequests": 0,\n    "maxHttp10ResponseSize": 0,\n    "maxLogsSize": 0,\n    "middleFingers": false,\n    "perIpThrottlingQuota": 0,\n    "privateAppsAuth0Config": {},\n    "streamEntityOnly": false,\n    "throttlingQuota": 0,\n    "u2fLoginOnly": false,\n    "useCircuitBreakers": false\n  },\n  "date": "",\n  "dateRaw": 0,\n  "errorTemplates": [\n    {\n      "messages": {},\n      "serviceId": "",\n      "template40x": "",\n      "template50x": "",\n      "templateBuild": "",\n      "templateMaintenance": ""\n    }\n  ],\n  "label": "",\n  "serviceDescriptors": [\n    {\n      "Canary": {\n        "enabled": false,\n        "root": "",\n        "targets": [\n          {\n            "host": "",\n            "scheme": ""\n          }\n        ],\n        "traffic": 0\n      },\n      "additionalHeaders": {},\n      "api": {\n        "exposeApi": false,\n        "openApiDescriptorUrl": ""\n      },\n      "authConfigRef": "",\n      "buildMode": false,\n      "chaosConfig": {\n        "badResponsesFaultConfig": {\n          "ratio": "",\n          "responses": [\n            {\n              "body": "",\n              "headers": {},\n              "status": 0\n            }\n          ]\n        },\n        "enabled": false,\n        "largeRequestFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "largeResponseFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "latencyInjectionFaultConfig": {\n          "from": 0,\n          "ratio": "",\n          "to": 0\n        }\n      },\n      "clientConfig": {\n        "backoffFactor": 0,\n        "callTimeout": 0,\n        "globalTimeout": 0,\n        "maxErrors": 0,\n        "retries": 0,\n        "retryInitialDelay": 0,\n        "sampleInterval": 0,\n        "useCircuitBreaker": false\n      },\n      "clientValidatorRef": "",\n      "cors": {\n        "allowCredentials": false,\n        "allowHeaders": [],\n        "allowMethods": [],\n        "allowOrigin": "",\n        "enabled": false,\n        "excludedPatterns": [],\n        "exposeHeaders": [],\n        "maxAge": 0\n      },\n      "domain": "",\n      "enabled": false,\n      "enforceSecureCommunication": false,\n      "env": "",\n      "forceHttps": false,\n      "groups": [],\n      "gzip": {\n        "blackList": [],\n        "bufferSize": 0,\n        "chunkedThreshold": 0,\n        "compressionLevel": 0,\n        "enabled": false,\n        "excludedPatterns": [],\n        "whiteList": []\n      },\n      "headersVerification": {},\n      "healthCheck": {\n        "enabled": false,\n        "url": ""\n      },\n      "id": "",\n      "ipFiltering": {},\n      "jwtVerifier": "",\n      "localHost": "",\n      "localScheme": "",\n      "maintenanceMode": false,\n      "matchingHeaders": {},\n      "matchingRoot": "",\n      "metadata": {},\n      "name": "",\n      "overrideHost": false,\n      "privateApp": false,\n      "privatePatterns": [],\n      "publicPatterns": [],\n      "redirectToLocal": false,\n      "redirection": {\n        "code": 0,\n        "enabled": false,\n        "to": ""\n      },\n      "root": "",\n      "secComExcludedPatterns": [],\n      "secComSettings": "",\n      "sendOtoroshiHeadersBack": false,\n      "statsdConfig": {\n        "datadog": false,\n        "host": "",\n        "port": 0\n      },\n      "subdomain": "",\n      "targets": [\n        {}\n      ],\n      "transformerRef": "",\n      "userFacing": false,\n      "xForwardedHeaders": false\n    }\n  ],\n  "serviceGroups": [\n    {\n      "description": "",\n      "id": "",\n      "name": ""\n    }\n  ],\n  "simpleAdmins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "username": ""\n    }\n  ],\n  "stats": {\n    "calls": 0,\n    "dataIn": 0,\n    "dataOut": 0\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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/otoroshi.json")
  .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/api/otoroshi.json',
  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({
  admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
  apiKeys: [
    {
      authorizedEntities: [],
      clientId: '',
      clientName: '',
      clientSecret: '',
      dailyQuota: 0,
      enabled: false,
      metadata: {},
      monthlyQuota: 0,
      throttlingQuota: 0
    }
  ],
  appConfig: {},
  config: {
    alertsEmails: [],
    alertsWebhooks: [{headers: {}, url: ''}],
    analyticsWebhooks: [{}],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
    cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
    elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
    elasticWritesConfigs: [{}],
    endlessIpAddresses: [],
    ipFiltering: {blacklist: [], whitelist: []},
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  },
  date: '',
  dateRaw: 0,
  errorTemplates: [
    {
      messages: {},
      serviceId: '',
      template40x: '',
      template50x: '',
      templateBuild: '',
      templateMaintenance: ''
    }
  ],
  label: '',
  serviceDescriptors: [
    {
      Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
      additionalHeaders: {},
      api: {exposeApi: false, openApiDescriptorUrl: ''},
      authConfigRef: '',
      buildMode: false,
      chaosConfig: {
        badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
        enabled: false,
        largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
        largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
        latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
      },
      clientConfig: {
        backoffFactor: 0,
        callTimeout: 0,
        globalTimeout: 0,
        maxErrors: 0,
        retries: 0,
        retryInitialDelay: 0,
        sampleInterval: 0,
        useCircuitBreaker: false
      },
      clientValidatorRef: '',
      cors: {
        allowCredentials: false,
        allowHeaders: [],
        allowMethods: [],
        allowOrigin: '',
        enabled: false,
        excludedPatterns: [],
        exposeHeaders: [],
        maxAge: 0
      },
      domain: '',
      enabled: false,
      enforceSecureCommunication: false,
      env: '',
      forceHttps: false,
      groups: [],
      gzip: {
        blackList: [],
        bufferSize: 0,
        chunkedThreshold: 0,
        compressionLevel: 0,
        enabled: false,
        excludedPatterns: [],
        whiteList: []
      },
      headersVerification: {},
      healthCheck: {enabled: false, url: ''},
      id: '',
      ipFiltering: {},
      jwtVerifier: '',
      localHost: '',
      localScheme: '',
      maintenanceMode: false,
      matchingHeaders: {},
      matchingRoot: '',
      metadata: {},
      name: '',
      overrideHost: false,
      privateApp: false,
      privatePatterns: [],
      publicPatterns: [],
      redirectToLocal: false,
      redirection: {code: 0, enabled: false, to: ''},
      root: '',
      secComExcludedPatterns: [],
      secComSettings: '',
      sendOtoroshiHeadersBack: false,
      statsdConfig: {datadog: false, host: '', port: 0},
      subdomain: '',
      targets: [{}],
      transformerRef: '',
      userFacing: false,
      xForwardedHeaders: false
    }
  ],
  serviceGroups: [{description: '', id: '', name: ''}],
  simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
  stats: {calls: 0, dataIn: 0, dataOut: 0}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/otoroshi.json',
  headers: {'content-type': 'application/json'},
  body: {
    admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
    apiKeys: [
      {
        authorizedEntities: [],
        clientId: '',
        clientName: '',
        clientSecret: '',
        dailyQuota: 0,
        enabled: false,
        metadata: {},
        monthlyQuota: 0,
        throttlingQuota: 0
      }
    ],
    appConfig: {},
    config: {
      alertsEmails: [],
      alertsWebhooks: [{headers: {}, url: ''}],
      analyticsWebhooks: [{}],
      apiReadOnly: false,
      autoLinkToDefaultGroup: false,
      backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
      cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
      elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
      elasticWritesConfigs: [{}],
      endlessIpAddresses: [],
      ipFiltering: {blacklist: [], whitelist: []},
      limitConcurrentRequests: false,
      lines: [],
      mailerSettings: {
        apiKey: '',
        apiKeyPrivate: '',
        apiKeyPublic: '',
        domain: '',
        eu: false,
        header: {},
        type: '',
        url: ''
      },
      maxConcurrentRequests: 0,
      maxHttp10ResponseSize: 0,
      maxLogsSize: 0,
      middleFingers: false,
      perIpThrottlingQuota: 0,
      privateAppsAuth0Config: {},
      streamEntityOnly: false,
      throttlingQuota: 0,
      u2fLoginOnly: false,
      useCircuitBreakers: false
    },
    date: '',
    dateRaw: 0,
    errorTemplates: [
      {
        messages: {},
        serviceId: '',
        template40x: '',
        template50x: '',
        templateBuild: '',
        templateMaintenance: ''
      }
    ],
    label: '',
    serviceDescriptors: [
      {
        Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
        additionalHeaders: {},
        api: {exposeApi: false, openApiDescriptorUrl: ''},
        authConfigRef: '',
        buildMode: false,
        chaosConfig: {
          badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
          enabled: false,
          largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
          largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
          latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
        },
        clientConfig: {
          backoffFactor: 0,
          callTimeout: 0,
          globalTimeout: 0,
          maxErrors: 0,
          retries: 0,
          retryInitialDelay: 0,
          sampleInterval: 0,
          useCircuitBreaker: false
        },
        clientValidatorRef: '',
        cors: {
          allowCredentials: false,
          allowHeaders: [],
          allowMethods: [],
          allowOrigin: '',
          enabled: false,
          excludedPatterns: [],
          exposeHeaders: [],
          maxAge: 0
        },
        domain: '',
        enabled: false,
        enforceSecureCommunication: false,
        env: '',
        forceHttps: false,
        groups: [],
        gzip: {
          blackList: [],
          bufferSize: 0,
          chunkedThreshold: 0,
          compressionLevel: 0,
          enabled: false,
          excludedPatterns: [],
          whiteList: []
        },
        headersVerification: {},
        healthCheck: {enabled: false, url: ''},
        id: '',
        ipFiltering: {},
        jwtVerifier: '',
        localHost: '',
        localScheme: '',
        maintenanceMode: false,
        matchingHeaders: {},
        matchingRoot: '',
        metadata: {},
        name: '',
        overrideHost: false,
        privateApp: false,
        privatePatterns: [],
        publicPatterns: [],
        redirectToLocal: false,
        redirection: {code: 0, enabled: false, to: ''},
        root: '',
        secComExcludedPatterns: [],
        secComSettings: '',
        sendOtoroshiHeadersBack: false,
        statsdConfig: {datadog: false, host: '', port: 0},
        subdomain: '',
        targets: [{}],
        transformerRef: '',
        userFacing: false,
        xForwardedHeaders: false
      }
    ],
    serviceGroups: [{description: '', id: '', name: ''}],
    simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
    stats: {calls: 0, dataIn: 0, dataOut: 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}}/api/otoroshi.json');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  admins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      registration: {},
      username: ''
    }
  ],
  apiKeys: [
    {
      authorizedEntities: [],
      clientId: '',
      clientName: '',
      clientSecret: '',
      dailyQuota: 0,
      enabled: false,
      metadata: {},
      monthlyQuota: 0,
      throttlingQuota: 0
    }
  ],
  appConfig: {},
  config: {
    alertsEmails: [],
    alertsWebhooks: [
      {
        headers: {},
        url: ''
      }
    ],
    analyticsWebhooks: [
      {}
    ],
    apiReadOnly: false,
    autoLinkToDefaultGroup: false,
    backofficeAuth0Config: {
      callbackUrl: '',
      clientId: '',
      clientSecret: '',
      domain: ''
    },
    cleverSettings: {
      consumerKey: '',
      consumerSecret: '',
      orgaId: '',
      secret: '',
      token: ''
    },
    elasticReadsConfig: {
      clusterUri: '',
      headers: {},
      index: '',
      password: '',
      type: '',
      user: ''
    },
    elasticWritesConfigs: [
      {}
    ],
    endlessIpAddresses: [],
    ipFiltering: {
      blacklist: [],
      whitelist: []
    },
    limitConcurrentRequests: false,
    lines: [],
    mailerSettings: {
      apiKey: '',
      apiKeyPrivate: '',
      apiKeyPublic: '',
      domain: '',
      eu: false,
      header: {},
      type: '',
      url: ''
    },
    maxConcurrentRequests: 0,
    maxHttp10ResponseSize: 0,
    maxLogsSize: 0,
    middleFingers: false,
    perIpThrottlingQuota: 0,
    privateAppsAuth0Config: {},
    streamEntityOnly: false,
    throttlingQuota: 0,
    u2fLoginOnly: false,
    useCircuitBreakers: false
  },
  date: '',
  dateRaw: 0,
  errorTemplates: [
    {
      messages: {},
      serviceId: '',
      template40x: '',
      template50x: '',
      templateBuild: '',
      templateMaintenance: ''
    }
  ],
  label: '',
  serviceDescriptors: [
    {
      Canary: {
        enabled: false,
        root: '',
        targets: [
          {
            host: '',
            scheme: ''
          }
        ],
        traffic: 0
      },
      additionalHeaders: {},
      api: {
        exposeApi: false,
        openApiDescriptorUrl: ''
      },
      authConfigRef: '',
      buildMode: false,
      chaosConfig: {
        badResponsesFaultConfig: {
          ratio: '',
          responses: [
            {
              body: '',
              headers: {},
              status: 0
            }
          ]
        },
        enabled: false,
        largeRequestFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        largeResponseFaultConfig: {
          additionalRequestSize: 0,
          ratio: ''
        },
        latencyInjectionFaultConfig: {
          from: 0,
          ratio: '',
          to: 0
        }
      },
      clientConfig: {
        backoffFactor: 0,
        callTimeout: 0,
        globalTimeout: 0,
        maxErrors: 0,
        retries: 0,
        retryInitialDelay: 0,
        sampleInterval: 0,
        useCircuitBreaker: false
      },
      clientValidatorRef: '',
      cors: {
        allowCredentials: false,
        allowHeaders: [],
        allowMethods: [],
        allowOrigin: '',
        enabled: false,
        excludedPatterns: [],
        exposeHeaders: [],
        maxAge: 0
      },
      domain: '',
      enabled: false,
      enforceSecureCommunication: false,
      env: '',
      forceHttps: false,
      groups: [],
      gzip: {
        blackList: [],
        bufferSize: 0,
        chunkedThreshold: 0,
        compressionLevel: 0,
        enabled: false,
        excludedPatterns: [],
        whiteList: []
      },
      headersVerification: {},
      healthCheck: {
        enabled: false,
        url: ''
      },
      id: '',
      ipFiltering: {},
      jwtVerifier: '',
      localHost: '',
      localScheme: '',
      maintenanceMode: false,
      matchingHeaders: {},
      matchingRoot: '',
      metadata: {},
      name: '',
      overrideHost: false,
      privateApp: false,
      privatePatterns: [],
      publicPatterns: [],
      redirectToLocal: false,
      redirection: {
        code: 0,
        enabled: false,
        to: ''
      },
      root: '',
      secComExcludedPatterns: [],
      secComSettings: '',
      sendOtoroshiHeadersBack: false,
      statsdConfig: {
        datadog: false,
        host: '',
        port: 0
      },
      subdomain: '',
      targets: [
        {}
      ],
      transformerRef: '',
      userFacing: false,
      xForwardedHeaders: false
    }
  ],
  serviceGroups: [
    {
      description: '',
      id: '',
      name: ''
    }
  ],
  simpleAdmins: [
    {
      createdAt: 0,
      label: '',
      password: '',
      username: ''
    }
  ],
  stats: {
    calls: 0,
    dataIn: 0,
    dataOut: 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}}/api/otoroshi.json',
  headers: {'content-type': 'application/json'},
  data: {
    admins: [{createdAt: 0, label: '', password: '', registration: {}, username: ''}],
    apiKeys: [
      {
        authorizedEntities: [],
        clientId: '',
        clientName: '',
        clientSecret: '',
        dailyQuota: 0,
        enabled: false,
        metadata: {},
        monthlyQuota: 0,
        throttlingQuota: 0
      }
    ],
    appConfig: {},
    config: {
      alertsEmails: [],
      alertsWebhooks: [{headers: {}, url: ''}],
      analyticsWebhooks: [{}],
      apiReadOnly: false,
      autoLinkToDefaultGroup: false,
      backofficeAuth0Config: {callbackUrl: '', clientId: '', clientSecret: '', domain: ''},
      cleverSettings: {consumerKey: '', consumerSecret: '', orgaId: '', secret: '', token: ''},
      elasticReadsConfig: {clusterUri: '', headers: {}, index: '', password: '', type: '', user: ''},
      elasticWritesConfigs: [{}],
      endlessIpAddresses: [],
      ipFiltering: {blacklist: [], whitelist: []},
      limitConcurrentRequests: false,
      lines: [],
      mailerSettings: {
        apiKey: '',
        apiKeyPrivate: '',
        apiKeyPublic: '',
        domain: '',
        eu: false,
        header: {},
        type: '',
        url: ''
      },
      maxConcurrentRequests: 0,
      maxHttp10ResponseSize: 0,
      maxLogsSize: 0,
      middleFingers: false,
      perIpThrottlingQuota: 0,
      privateAppsAuth0Config: {},
      streamEntityOnly: false,
      throttlingQuota: 0,
      u2fLoginOnly: false,
      useCircuitBreakers: false
    },
    date: '',
    dateRaw: 0,
    errorTemplates: [
      {
        messages: {},
        serviceId: '',
        template40x: '',
        template50x: '',
        templateBuild: '',
        templateMaintenance: ''
      }
    ],
    label: '',
    serviceDescriptors: [
      {
        Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
        additionalHeaders: {},
        api: {exposeApi: false, openApiDescriptorUrl: ''},
        authConfigRef: '',
        buildMode: false,
        chaosConfig: {
          badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
          enabled: false,
          largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
          largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
          latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
        },
        clientConfig: {
          backoffFactor: 0,
          callTimeout: 0,
          globalTimeout: 0,
          maxErrors: 0,
          retries: 0,
          retryInitialDelay: 0,
          sampleInterval: 0,
          useCircuitBreaker: false
        },
        clientValidatorRef: '',
        cors: {
          allowCredentials: false,
          allowHeaders: [],
          allowMethods: [],
          allowOrigin: '',
          enabled: false,
          excludedPatterns: [],
          exposeHeaders: [],
          maxAge: 0
        },
        domain: '',
        enabled: false,
        enforceSecureCommunication: false,
        env: '',
        forceHttps: false,
        groups: [],
        gzip: {
          blackList: [],
          bufferSize: 0,
          chunkedThreshold: 0,
          compressionLevel: 0,
          enabled: false,
          excludedPatterns: [],
          whiteList: []
        },
        headersVerification: {},
        healthCheck: {enabled: false, url: ''},
        id: '',
        ipFiltering: {},
        jwtVerifier: '',
        localHost: '',
        localScheme: '',
        maintenanceMode: false,
        matchingHeaders: {},
        matchingRoot: '',
        metadata: {},
        name: '',
        overrideHost: false,
        privateApp: false,
        privatePatterns: [],
        publicPatterns: [],
        redirectToLocal: false,
        redirection: {code: 0, enabled: false, to: ''},
        root: '',
        secComExcludedPatterns: [],
        secComSettings: '',
        sendOtoroshiHeadersBack: false,
        statsdConfig: {datadog: false, host: '', port: 0},
        subdomain: '',
        targets: [{}],
        transformerRef: '',
        userFacing: false,
        xForwardedHeaders: false
      }
    ],
    serviceGroups: [{description: '', id: '', name: ''}],
    simpleAdmins: [{createdAt: 0, label: '', password: '', username: ''}],
    stats: {calls: 0, dataIn: 0, dataOut: 0}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/otoroshi.json';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"admins":[{"createdAt":0,"label":"","password":"","registration":{},"username":""}],"apiKeys":[{"authorizedEntities":[],"clientId":"","clientName":"","clientSecret":"","dailyQuota":0,"enabled":false,"metadata":{},"monthlyQuota":0,"throttlingQuota":0}],"appConfig":{},"config":{"alertsEmails":[],"alertsWebhooks":[{"headers":{},"url":""}],"analyticsWebhooks":[{}],"apiReadOnly":false,"autoLinkToDefaultGroup":false,"backofficeAuth0Config":{"callbackUrl":"","clientId":"","clientSecret":"","domain":""},"cleverSettings":{"consumerKey":"","consumerSecret":"","orgaId":"","secret":"","token":""},"elasticReadsConfig":{"clusterUri":"","headers":{},"index":"","password":"","type":"","user":""},"elasticWritesConfigs":[{}],"endlessIpAddresses":[],"ipFiltering":{"blacklist":[],"whitelist":[]},"limitConcurrentRequests":false,"lines":[],"mailerSettings":{"apiKey":"","apiKeyPrivate":"","apiKeyPublic":"","domain":"","eu":false,"header":{},"type":"","url":""},"maxConcurrentRequests":0,"maxHttp10ResponseSize":0,"maxLogsSize":0,"middleFingers":false,"perIpThrottlingQuota":0,"privateAppsAuth0Config":{},"streamEntityOnly":false,"throttlingQuota":0,"u2fLoginOnly":false,"useCircuitBreakers":false},"date":"","dateRaw":0,"errorTemplates":[{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}],"label":"","serviceDescriptors":[{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}],"serviceGroups":[{"description":"","id":"","name":""}],"simpleAdmins":[{"createdAt":0,"label":"","password":"","username":""}],"stats":{"calls":0,"dataIn":0,"dataOut":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 = @{ @"admins": @[ @{ @"createdAt": @0, @"label": @"", @"password": @"", @"registration": @{  }, @"username": @"" } ],
                              @"apiKeys": @[ @{ @"authorizedEntities": @[  ], @"clientId": @"", @"clientName": @"", @"clientSecret": @"", @"dailyQuota": @0, @"enabled": @NO, @"metadata": @{  }, @"monthlyQuota": @0, @"throttlingQuota": @0 } ],
                              @"appConfig": @{  },
                              @"config": @{ @"alertsEmails": @[  ], @"alertsWebhooks": @[ @{ @"headers": @{  }, @"url": @"" } ], @"analyticsWebhooks": @[ @{  } ], @"apiReadOnly": @NO, @"autoLinkToDefaultGroup": @NO, @"backofficeAuth0Config": @{ @"callbackUrl": @"", @"clientId": @"", @"clientSecret": @"", @"domain": @"" }, @"cleverSettings": @{ @"consumerKey": @"", @"consumerSecret": @"", @"orgaId": @"", @"secret": @"", @"token": @"" }, @"elasticReadsConfig": @{ @"clusterUri": @"", @"headers": @{  }, @"index": @"", @"password": @"", @"type": @"", @"user": @"" }, @"elasticWritesConfigs": @[ @{  } ], @"endlessIpAddresses": @[  ], @"ipFiltering": @{ @"blacklist": @[  ], @"whitelist": @[  ] }, @"limitConcurrentRequests": @NO, @"lines": @[  ], @"mailerSettings": @{ @"apiKey": @"", @"apiKeyPrivate": @"", @"apiKeyPublic": @"", @"domain": @"", @"eu": @NO, @"header": @{  }, @"type": @"", @"url": @"" }, @"maxConcurrentRequests": @0, @"maxHttp10ResponseSize": @0, @"maxLogsSize": @0, @"middleFingers": @NO, @"perIpThrottlingQuota": @0, @"privateAppsAuth0Config": @{  }, @"streamEntityOnly": @NO, @"throttlingQuota": @0, @"u2fLoginOnly": @NO, @"useCircuitBreakers": @NO },
                              @"date": @"",
                              @"dateRaw": @0,
                              @"errorTemplates": @[ @{ @"messages": @{  }, @"serviceId": @"", @"template40x": @"", @"template50x": @"", @"templateBuild": @"", @"templateMaintenance": @"" } ],
                              @"label": @"",
                              @"serviceDescriptors": @[ @{ @"Canary": @{ @"enabled": @NO, @"root": @"", @"targets": @[ @{ @"host": @"", @"scheme": @"" } ], @"traffic": @0 }, @"additionalHeaders": @{  }, @"api": @{ @"exposeApi": @NO, @"openApiDescriptorUrl": @"" }, @"authConfigRef": @"", @"buildMode": @NO, @"chaosConfig": @{ @"badResponsesFaultConfig": @{ @"ratio": @"", @"responses": @[ @{ @"body": @"", @"headers": @{  }, @"status": @0 } ] }, @"enabled": @NO, @"largeRequestFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"largeResponseFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"latencyInjectionFaultConfig": @{ @"from": @0, @"ratio": @"", @"to": @0 } }, @"clientConfig": @{ @"backoffFactor": @0, @"callTimeout": @0, @"globalTimeout": @0, @"maxErrors": @0, @"retries": @0, @"retryInitialDelay": @0, @"sampleInterval": @0, @"useCircuitBreaker": @NO }, @"clientValidatorRef": @"", @"cors": @{ @"allowCredentials": @NO, @"allowHeaders": @[  ], @"allowMethods": @[  ], @"allowOrigin": @"", @"enabled": @NO, @"excludedPatterns": @[  ], @"exposeHeaders": @[  ], @"maxAge": @0 }, @"domain": @"", @"enabled": @NO, @"enforceSecureCommunication": @NO, @"env": @"", @"forceHttps": @NO, @"groups": @[  ], @"gzip": @{ @"blackList": @[  ], @"bufferSize": @0, @"chunkedThreshold": @0, @"compressionLevel": @0, @"enabled": @NO, @"excludedPatterns": @[  ], @"whiteList": @[  ] }, @"headersVerification": @{  }, @"healthCheck": @{ @"enabled": @NO, @"url": @"" }, @"id": @"", @"ipFiltering": @{  }, @"jwtVerifier": @"", @"localHost": @"", @"localScheme": @"", @"maintenanceMode": @NO, @"matchingHeaders": @{  }, @"matchingRoot": @"", @"metadata": @{  }, @"name": @"", @"overrideHost": @NO, @"privateApp": @NO, @"privatePatterns": @[  ], @"publicPatterns": @[  ], @"redirectToLocal": @NO, @"redirection": @{ @"code": @0, @"enabled": @NO, @"to": @"" }, @"root": @"", @"secComExcludedPatterns": @[  ], @"secComSettings": @"", @"sendOtoroshiHeadersBack": @NO, @"statsdConfig": @{ @"datadog": @NO, @"host": @"", @"port": @0 }, @"subdomain": @"", @"targets": @[ @{  } ], @"transformerRef": @"", @"userFacing": @NO, @"xForwardedHeaders": @NO } ],
                              @"serviceGroups": @[ @{ @"description": @"", @"id": @"", @"name": @"" } ],
                              @"simpleAdmins": @[ @{ @"createdAt": @0, @"label": @"", @"password": @"", @"username": @"" } ],
                              @"stats": @{ @"calls": @0, @"dataIn": @0, @"dataOut": @0 } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/otoroshi.json"]
                                                       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}}/api/otoroshi.json" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/otoroshi.json",
  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([
    'admins' => [
        [
                'createdAt' => 0,
                'label' => '',
                'password' => '',
                'registration' => [
                                
                ],
                'username' => ''
        ]
    ],
    'apiKeys' => [
        [
                'authorizedEntities' => [
                                
                ],
                'clientId' => '',
                'clientName' => '',
                'clientSecret' => '',
                'dailyQuota' => 0,
                'enabled' => null,
                'metadata' => [
                                
                ],
                'monthlyQuota' => 0,
                'throttlingQuota' => 0
        ]
    ],
    'appConfig' => [
        
    ],
    'config' => [
        'alertsEmails' => [
                
        ],
        'alertsWebhooks' => [
                [
                                'headers' => [
                                                                
                                ],
                                'url' => ''
                ]
        ],
        'analyticsWebhooks' => [
                [
                                
                ]
        ],
        'apiReadOnly' => null,
        'autoLinkToDefaultGroup' => null,
        'backofficeAuth0Config' => [
                'callbackUrl' => '',
                'clientId' => '',
                'clientSecret' => '',
                'domain' => ''
        ],
        'cleverSettings' => [
                'consumerKey' => '',
                'consumerSecret' => '',
                'orgaId' => '',
                'secret' => '',
                'token' => ''
        ],
        'elasticReadsConfig' => [
                'clusterUri' => '',
                'headers' => [
                                
                ],
                'index' => '',
                'password' => '',
                'type' => '',
                'user' => ''
        ],
        'elasticWritesConfigs' => [
                [
                                
                ]
        ],
        'endlessIpAddresses' => [
                
        ],
        'ipFiltering' => [
                'blacklist' => [
                                
                ],
                'whitelist' => [
                                
                ]
        ],
        'limitConcurrentRequests' => null,
        'lines' => [
                
        ],
        'mailerSettings' => [
                'apiKey' => '',
                'apiKeyPrivate' => '',
                'apiKeyPublic' => '',
                'domain' => '',
                'eu' => null,
                'header' => [
                                
                ],
                'type' => '',
                'url' => ''
        ],
        'maxConcurrentRequests' => 0,
        'maxHttp10ResponseSize' => 0,
        'maxLogsSize' => 0,
        'middleFingers' => null,
        'perIpThrottlingQuota' => 0,
        'privateAppsAuth0Config' => [
                
        ],
        'streamEntityOnly' => null,
        'throttlingQuota' => 0,
        'u2fLoginOnly' => null,
        'useCircuitBreakers' => null
    ],
    'date' => '',
    'dateRaw' => 0,
    'errorTemplates' => [
        [
                'messages' => [
                                
                ],
                'serviceId' => '',
                'template40x' => '',
                'template50x' => '',
                'templateBuild' => '',
                'templateMaintenance' => ''
        ]
    ],
    'label' => '',
    'serviceDescriptors' => [
        [
                'Canary' => [
                                'enabled' => null,
                                'root' => '',
                                'targets' => [
                                                                [
                                                                                                                                'host' => '',
                                                                                                                                'scheme' => ''
                                                                ]
                                ],
                                'traffic' => 0
                ],
                'additionalHeaders' => [
                                
                ],
                'api' => [
                                'exposeApi' => null,
                                'openApiDescriptorUrl' => ''
                ],
                'authConfigRef' => '',
                'buildMode' => null,
                'chaosConfig' => [
                                'badResponsesFaultConfig' => [
                                                                'ratio' => '',
                                                                'responses' => [
                                                                                                                                [
                                                                                                                                                                                                                                                                'body' => '',
                                                                                                                                                                                                                                                                'headers' => [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                ],
                                                                                                                                                                                                                                                                'status' => 0
                                                                                                                                ]
                                                                ]
                                ],
                                'enabled' => null,
                                'largeRequestFaultConfig' => [
                                                                'additionalRequestSize' => 0,
                                                                'ratio' => ''
                                ],
                                'largeResponseFaultConfig' => [
                                                                'additionalRequestSize' => 0,
                                                                'ratio' => ''
                                ],
                                'latencyInjectionFaultConfig' => [
                                                                'from' => 0,
                                                                'ratio' => '',
                                                                'to' => 0
                                ]
                ],
                'clientConfig' => [
                                'backoffFactor' => 0,
                                'callTimeout' => 0,
                                'globalTimeout' => 0,
                                'maxErrors' => 0,
                                'retries' => 0,
                                'retryInitialDelay' => 0,
                                'sampleInterval' => 0,
                                'useCircuitBreaker' => null
                ],
                'clientValidatorRef' => '',
                'cors' => [
                                'allowCredentials' => null,
                                'allowHeaders' => [
                                                                
                                ],
                                'allowMethods' => [
                                                                
                                ],
                                'allowOrigin' => '',
                                'enabled' => null,
                                'excludedPatterns' => [
                                                                
                                ],
                                'exposeHeaders' => [
                                                                
                                ],
                                'maxAge' => 0
                ],
                'domain' => '',
                'enabled' => null,
                'enforceSecureCommunication' => null,
                'env' => '',
                'forceHttps' => null,
                'groups' => [
                                
                ],
                'gzip' => [
                                'blackList' => [
                                                                
                                ],
                                'bufferSize' => 0,
                                'chunkedThreshold' => 0,
                                'compressionLevel' => 0,
                                'enabled' => null,
                                'excludedPatterns' => [
                                                                
                                ],
                                'whiteList' => [
                                                                
                                ]
                ],
                'headersVerification' => [
                                
                ],
                'healthCheck' => [
                                'enabled' => null,
                                'url' => ''
                ],
                'id' => '',
                'ipFiltering' => [
                                
                ],
                'jwtVerifier' => '',
                'localHost' => '',
                'localScheme' => '',
                'maintenanceMode' => null,
                'matchingHeaders' => [
                                
                ],
                'matchingRoot' => '',
                'metadata' => [
                                
                ],
                'name' => '',
                'overrideHost' => null,
                'privateApp' => null,
                'privatePatterns' => [
                                
                ],
                'publicPatterns' => [
                                
                ],
                'redirectToLocal' => null,
                'redirection' => [
                                'code' => 0,
                                'enabled' => null,
                                'to' => ''
                ],
                'root' => '',
                'secComExcludedPatterns' => [
                                
                ],
                'secComSettings' => '',
                'sendOtoroshiHeadersBack' => null,
                'statsdConfig' => [
                                'datadog' => null,
                                'host' => '',
                                'port' => 0
                ],
                'subdomain' => '',
                'targets' => [
                                [
                                                                
                                ]
                ],
                'transformerRef' => '',
                'userFacing' => null,
                'xForwardedHeaders' => null
        ]
    ],
    'serviceGroups' => [
        [
                'description' => '',
                'id' => '',
                'name' => ''
        ]
    ],
    'simpleAdmins' => [
        [
                'createdAt' => 0,
                'label' => '',
                'password' => '',
                'username' => ''
        ]
    ],
    'stats' => [
        'calls' => 0,
        'dataIn' => 0,
        'dataOut' => 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}}/api/otoroshi.json', [
  'body' => '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/otoroshi.json');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'admins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'registration' => [
                
        ],
        'username' => ''
    ]
  ],
  'apiKeys' => [
    [
        'authorizedEntities' => [
                
        ],
        'clientId' => '',
        'clientName' => '',
        'clientSecret' => '',
        'dailyQuota' => 0,
        'enabled' => null,
        'metadata' => [
                
        ],
        'monthlyQuota' => 0,
        'throttlingQuota' => 0
    ]
  ],
  'appConfig' => [
    
  ],
  'config' => [
    'alertsEmails' => [
        
    ],
    'alertsWebhooks' => [
        [
                'headers' => [
                                
                ],
                'url' => ''
        ]
    ],
    'analyticsWebhooks' => [
        [
                
        ]
    ],
    'apiReadOnly' => null,
    'autoLinkToDefaultGroup' => null,
    'backofficeAuth0Config' => [
        'callbackUrl' => '',
        'clientId' => '',
        'clientSecret' => '',
        'domain' => ''
    ],
    'cleverSettings' => [
        'consumerKey' => '',
        'consumerSecret' => '',
        'orgaId' => '',
        'secret' => '',
        'token' => ''
    ],
    'elasticReadsConfig' => [
        'clusterUri' => '',
        'headers' => [
                
        ],
        'index' => '',
        'password' => '',
        'type' => '',
        'user' => ''
    ],
    'elasticWritesConfigs' => [
        [
                
        ]
    ],
    'endlessIpAddresses' => [
        
    ],
    'ipFiltering' => [
        'blacklist' => [
                
        ],
        'whitelist' => [
                
        ]
    ],
    'limitConcurrentRequests' => null,
    'lines' => [
        
    ],
    'mailerSettings' => [
        'apiKey' => '',
        'apiKeyPrivate' => '',
        'apiKeyPublic' => '',
        'domain' => '',
        'eu' => null,
        'header' => [
                
        ],
        'type' => '',
        'url' => ''
    ],
    'maxConcurrentRequests' => 0,
    'maxHttp10ResponseSize' => 0,
    'maxLogsSize' => 0,
    'middleFingers' => null,
    'perIpThrottlingQuota' => 0,
    'privateAppsAuth0Config' => [
        
    ],
    'streamEntityOnly' => null,
    'throttlingQuota' => 0,
    'u2fLoginOnly' => null,
    'useCircuitBreakers' => null
  ],
  'date' => '',
  'dateRaw' => 0,
  'errorTemplates' => [
    [
        'messages' => [
                
        ],
        'serviceId' => '',
        'template40x' => '',
        'template50x' => '',
        'templateBuild' => '',
        'templateMaintenance' => ''
    ]
  ],
  'label' => '',
  'serviceDescriptors' => [
    [
        'Canary' => [
                'enabled' => null,
                'root' => '',
                'targets' => [
                                [
                                                                'host' => '',
                                                                'scheme' => ''
                                ]
                ],
                'traffic' => 0
        ],
        'additionalHeaders' => [
                
        ],
        'api' => [
                'exposeApi' => null,
                'openApiDescriptorUrl' => ''
        ],
        'authConfigRef' => '',
        'buildMode' => null,
        'chaosConfig' => [
                'badResponsesFaultConfig' => [
                                'ratio' => '',
                                'responses' => [
                                                                [
                                                                                                                                'body' => '',
                                                                                                                                'headers' => [
                                                                                                                                                                                                                                                                
                                                                                                                                ],
                                                                                                                                'status' => 0
                                                                ]
                                ]
                ],
                'enabled' => null,
                'largeRequestFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'largeResponseFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'latencyInjectionFaultConfig' => [
                                'from' => 0,
                                'ratio' => '',
                                'to' => 0
                ]
        ],
        'clientConfig' => [
                'backoffFactor' => 0,
                'callTimeout' => 0,
                'globalTimeout' => 0,
                'maxErrors' => 0,
                'retries' => 0,
                'retryInitialDelay' => 0,
                'sampleInterval' => 0,
                'useCircuitBreaker' => null
        ],
        'clientValidatorRef' => '',
        'cors' => [
                'allowCredentials' => null,
                'allowHeaders' => [
                                
                ],
                'allowMethods' => [
                                
                ],
                'allowOrigin' => '',
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'exposeHeaders' => [
                                
                ],
                'maxAge' => 0
        ],
        'domain' => '',
        'enabled' => null,
        'enforceSecureCommunication' => null,
        'env' => '',
        'forceHttps' => null,
        'groups' => [
                
        ],
        'gzip' => [
                'blackList' => [
                                
                ],
                'bufferSize' => 0,
                'chunkedThreshold' => 0,
                'compressionLevel' => 0,
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'whiteList' => [
                                
                ]
        ],
        'headersVerification' => [
                
        ],
        'healthCheck' => [
                'enabled' => null,
                'url' => ''
        ],
        'id' => '',
        'ipFiltering' => [
                
        ],
        'jwtVerifier' => '',
        'localHost' => '',
        'localScheme' => '',
        'maintenanceMode' => null,
        'matchingHeaders' => [
                
        ],
        'matchingRoot' => '',
        'metadata' => [
                
        ],
        'name' => '',
        'overrideHost' => null,
        'privateApp' => null,
        'privatePatterns' => [
                
        ],
        'publicPatterns' => [
                
        ],
        'redirectToLocal' => null,
        'redirection' => [
                'code' => 0,
                'enabled' => null,
                'to' => ''
        ],
        'root' => '',
        'secComExcludedPatterns' => [
                
        ],
        'secComSettings' => '',
        'sendOtoroshiHeadersBack' => null,
        'statsdConfig' => [
                'datadog' => null,
                'host' => '',
                'port' => 0
        ],
        'subdomain' => '',
        'targets' => [
                [
                                
                ]
        ],
        'transformerRef' => '',
        'userFacing' => null,
        'xForwardedHeaders' => null
    ]
  ],
  'serviceGroups' => [
    [
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ],
  'simpleAdmins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'username' => ''
    ]
  ],
  'stats' => [
    'calls' => 0,
    'dataIn' => 0,
    'dataOut' => 0
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'admins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'registration' => [
                
        ],
        'username' => ''
    ]
  ],
  'apiKeys' => [
    [
        'authorizedEntities' => [
                
        ],
        'clientId' => '',
        'clientName' => '',
        'clientSecret' => '',
        'dailyQuota' => 0,
        'enabled' => null,
        'metadata' => [
                
        ],
        'monthlyQuota' => 0,
        'throttlingQuota' => 0
    ]
  ],
  'appConfig' => [
    
  ],
  'config' => [
    'alertsEmails' => [
        
    ],
    'alertsWebhooks' => [
        [
                'headers' => [
                                
                ],
                'url' => ''
        ]
    ],
    'analyticsWebhooks' => [
        [
                
        ]
    ],
    'apiReadOnly' => null,
    'autoLinkToDefaultGroup' => null,
    'backofficeAuth0Config' => [
        'callbackUrl' => '',
        'clientId' => '',
        'clientSecret' => '',
        'domain' => ''
    ],
    'cleverSettings' => [
        'consumerKey' => '',
        'consumerSecret' => '',
        'orgaId' => '',
        'secret' => '',
        'token' => ''
    ],
    'elasticReadsConfig' => [
        'clusterUri' => '',
        'headers' => [
                
        ],
        'index' => '',
        'password' => '',
        'type' => '',
        'user' => ''
    ],
    'elasticWritesConfigs' => [
        [
                
        ]
    ],
    'endlessIpAddresses' => [
        
    ],
    'ipFiltering' => [
        'blacklist' => [
                
        ],
        'whitelist' => [
                
        ]
    ],
    'limitConcurrentRequests' => null,
    'lines' => [
        
    ],
    'mailerSettings' => [
        'apiKey' => '',
        'apiKeyPrivate' => '',
        'apiKeyPublic' => '',
        'domain' => '',
        'eu' => null,
        'header' => [
                
        ],
        'type' => '',
        'url' => ''
    ],
    'maxConcurrentRequests' => 0,
    'maxHttp10ResponseSize' => 0,
    'maxLogsSize' => 0,
    'middleFingers' => null,
    'perIpThrottlingQuota' => 0,
    'privateAppsAuth0Config' => [
        
    ],
    'streamEntityOnly' => null,
    'throttlingQuota' => 0,
    'u2fLoginOnly' => null,
    'useCircuitBreakers' => null
  ],
  'date' => '',
  'dateRaw' => 0,
  'errorTemplates' => [
    [
        'messages' => [
                
        ],
        'serviceId' => '',
        'template40x' => '',
        'template50x' => '',
        'templateBuild' => '',
        'templateMaintenance' => ''
    ]
  ],
  'label' => '',
  'serviceDescriptors' => [
    [
        'Canary' => [
                'enabled' => null,
                'root' => '',
                'targets' => [
                                [
                                                                'host' => '',
                                                                'scheme' => ''
                                ]
                ],
                'traffic' => 0
        ],
        'additionalHeaders' => [
                
        ],
        'api' => [
                'exposeApi' => null,
                'openApiDescriptorUrl' => ''
        ],
        'authConfigRef' => '',
        'buildMode' => null,
        'chaosConfig' => [
                'badResponsesFaultConfig' => [
                                'ratio' => '',
                                'responses' => [
                                                                [
                                                                                                                                'body' => '',
                                                                                                                                'headers' => [
                                                                                                                                                                                                                                                                
                                                                                                                                ],
                                                                                                                                'status' => 0
                                                                ]
                                ]
                ],
                'enabled' => null,
                'largeRequestFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'largeResponseFaultConfig' => [
                                'additionalRequestSize' => 0,
                                'ratio' => ''
                ],
                'latencyInjectionFaultConfig' => [
                                'from' => 0,
                                'ratio' => '',
                                'to' => 0
                ]
        ],
        'clientConfig' => [
                'backoffFactor' => 0,
                'callTimeout' => 0,
                'globalTimeout' => 0,
                'maxErrors' => 0,
                'retries' => 0,
                'retryInitialDelay' => 0,
                'sampleInterval' => 0,
                'useCircuitBreaker' => null
        ],
        'clientValidatorRef' => '',
        'cors' => [
                'allowCredentials' => null,
                'allowHeaders' => [
                                
                ],
                'allowMethods' => [
                                
                ],
                'allowOrigin' => '',
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'exposeHeaders' => [
                                
                ],
                'maxAge' => 0
        ],
        'domain' => '',
        'enabled' => null,
        'enforceSecureCommunication' => null,
        'env' => '',
        'forceHttps' => null,
        'groups' => [
                
        ],
        'gzip' => [
                'blackList' => [
                                
                ],
                'bufferSize' => 0,
                'chunkedThreshold' => 0,
                'compressionLevel' => 0,
                'enabled' => null,
                'excludedPatterns' => [
                                
                ],
                'whiteList' => [
                                
                ]
        ],
        'headersVerification' => [
                
        ],
        'healthCheck' => [
                'enabled' => null,
                'url' => ''
        ],
        'id' => '',
        'ipFiltering' => [
                
        ],
        'jwtVerifier' => '',
        'localHost' => '',
        'localScheme' => '',
        'maintenanceMode' => null,
        'matchingHeaders' => [
                
        ],
        'matchingRoot' => '',
        'metadata' => [
                
        ],
        'name' => '',
        'overrideHost' => null,
        'privateApp' => null,
        'privatePatterns' => [
                
        ],
        'publicPatterns' => [
                
        ],
        'redirectToLocal' => null,
        'redirection' => [
                'code' => 0,
                'enabled' => null,
                'to' => ''
        ],
        'root' => '',
        'secComExcludedPatterns' => [
                
        ],
        'secComSettings' => '',
        'sendOtoroshiHeadersBack' => null,
        'statsdConfig' => [
                'datadog' => null,
                'host' => '',
                'port' => 0
        ],
        'subdomain' => '',
        'targets' => [
                [
                                
                ]
        ],
        'transformerRef' => '',
        'userFacing' => null,
        'xForwardedHeaders' => null
    ]
  ],
  'serviceGroups' => [
    [
        'description' => '',
        'id' => '',
        'name' => ''
    ]
  ],
  'simpleAdmins' => [
    [
        'createdAt' => 0,
        'label' => '',
        'password' => '',
        'username' => ''
    ]
  ],
  'stats' => [
    'calls' => 0,
    'dataIn' => 0,
    'dataOut' => 0
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/otoroshi.json');
$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}}/api/otoroshi.json' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/otoroshi.json' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/otoroshi.json", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/otoroshi.json"

payload = {
    "admins": [
        {
            "createdAt": 0,
            "label": "",
            "password": "",
            "registration": {},
            "username": ""
        }
    ],
    "apiKeys": [
        {
            "authorizedEntities": [],
            "clientId": "",
            "clientName": "",
            "clientSecret": "",
            "dailyQuota": 0,
            "enabled": False,
            "metadata": {},
            "monthlyQuota": 0,
            "throttlingQuota": 0
        }
    ],
    "appConfig": {},
    "config": {
        "alertsEmails": [],
        "alertsWebhooks": [
            {
                "headers": {},
                "url": ""
            }
        ],
        "analyticsWebhooks": [{}],
        "apiReadOnly": False,
        "autoLinkToDefaultGroup": False,
        "backofficeAuth0Config": {
            "callbackUrl": "",
            "clientId": "",
            "clientSecret": "",
            "domain": ""
        },
        "cleverSettings": {
            "consumerKey": "",
            "consumerSecret": "",
            "orgaId": "",
            "secret": "",
            "token": ""
        },
        "elasticReadsConfig": {
            "clusterUri": "",
            "headers": {},
            "index": "",
            "password": "",
            "type": "",
            "user": ""
        },
        "elasticWritesConfigs": [{}],
        "endlessIpAddresses": [],
        "ipFiltering": {
            "blacklist": [],
            "whitelist": []
        },
        "limitConcurrentRequests": False,
        "lines": [],
        "mailerSettings": {
            "apiKey": "",
            "apiKeyPrivate": "",
            "apiKeyPublic": "",
            "domain": "",
            "eu": False,
            "header": {},
            "type": "",
            "url": ""
        },
        "maxConcurrentRequests": 0,
        "maxHttp10ResponseSize": 0,
        "maxLogsSize": 0,
        "middleFingers": False,
        "perIpThrottlingQuota": 0,
        "privateAppsAuth0Config": {},
        "streamEntityOnly": False,
        "throttlingQuota": 0,
        "u2fLoginOnly": False,
        "useCircuitBreakers": False
    },
    "date": "",
    "dateRaw": 0,
    "errorTemplates": [
        {
            "messages": {},
            "serviceId": "",
            "template40x": "",
            "template50x": "",
            "templateBuild": "",
            "templateMaintenance": ""
        }
    ],
    "label": "",
    "serviceDescriptors": [
        {
            "Canary": {
                "enabled": False,
                "root": "",
                "targets": [
                    {
                        "host": "",
                        "scheme": ""
                    }
                ],
                "traffic": 0
            },
            "additionalHeaders": {},
            "api": {
                "exposeApi": False,
                "openApiDescriptorUrl": ""
            },
            "authConfigRef": "",
            "buildMode": False,
            "chaosConfig": {
                "badResponsesFaultConfig": {
                    "ratio": "",
                    "responses": [
                        {
                            "body": "",
                            "headers": {},
                            "status": 0
                        }
                    ]
                },
                "enabled": False,
                "largeRequestFaultConfig": {
                    "additionalRequestSize": 0,
                    "ratio": ""
                },
                "largeResponseFaultConfig": {
                    "additionalRequestSize": 0,
                    "ratio": ""
                },
                "latencyInjectionFaultConfig": {
                    "from": 0,
                    "ratio": "",
                    "to": 0
                }
            },
            "clientConfig": {
                "backoffFactor": 0,
                "callTimeout": 0,
                "globalTimeout": 0,
                "maxErrors": 0,
                "retries": 0,
                "retryInitialDelay": 0,
                "sampleInterval": 0,
                "useCircuitBreaker": False
            },
            "clientValidatorRef": "",
            "cors": {
                "allowCredentials": False,
                "allowHeaders": [],
                "allowMethods": [],
                "allowOrigin": "",
                "enabled": False,
                "excludedPatterns": [],
                "exposeHeaders": [],
                "maxAge": 0
            },
            "domain": "",
            "enabled": False,
            "enforceSecureCommunication": False,
            "env": "",
            "forceHttps": False,
            "groups": [],
            "gzip": {
                "blackList": [],
                "bufferSize": 0,
                "chunkedThreshold": 0,
                "compressionLevel": 0,
                "enabled": False,
                "excludedPatterns": [],
                "whiteList": []
            },
            "headersVerification": {},
            "healthCheck": {
                "enabled": False,
                "url": ""
            },
            "id": "",
            "ipFiltering": {},
            "jwtVerifier": "",
            "localHost": "",
            "localScheme": "",
            "maintenanceMode": False,
            "matchingHeaders": {},
            "matchingRoot": "",
            "metadata": {},
            "name": "",
            "overrideHost": False,
            "privateApp": False,
            "privatePatterns": [],
            "publicPatterns": [],
            "redirectToLocal": False,
            "redirection": {
                "code": 0,
                "enabled": False,
                "to": ""
            },
            "root": "",
            "secComExcludedPatterns": [],
            "secComSettings": "",
            "sendOtoroshiHeadersBack": False,
            "statsdConfig": {
                "datadog": False,
                "host": "",
                "port": 0
            },
            "subdomain": "",
            "targets": [{}],
            "transformerRef": "",
            "userFacing": False,
            "xForwardedHeaders": False
        }
    ],
    "serviceGroups": [
        {
            "description": "",
            "id": "",
            "name": ""
        }
    ],
    "simpleAdmins": [
        {
            "createdAt": 0,
            "label": "",
            "password": "",
            "username": ""
        }
    ],
    "stats": {
        "calls": 0,
        "dataIn": 0,
        "dataOut": 0
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/otoroshi.json"

payload <- "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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}}/api/otoroshi.json")

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  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\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/api/otoroshi.json') do |req|
  req.body = "{\n  \"admins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"registration\": {},\n      \"username\": \"\"\n    }\n  ],\n  \"apiKeys\": [\n    {\n      \"authorizedEntities\": [],\n      \"clientId\": \"\",\n      \"clientName\": \"\",\n      \"clientSecret\": \"\",\n      \"dailyQuota\": 0,\n      \"enabled\": false,\n      \"metadata\": {},\n      \"monthlyQuota\": 0,\n      \"throttlingQuota\": 0\n    }\n  ],\n  \"appConfig\": {},\n  \"config\": {\n    \"alertsEmails\": [],\n    \"alertsWebhooks\": [\n      {\n        \"headers\": {},\n        \"url\": \"\"\n      }\n    ],\n    \"analyticsWebhooks\": [\n      {}\n    ],\n    \"apiReadOnly\": false,\n    \"autoLinkToDefaultGroup\": false,\n    \"backofficeAuth0Config\": {\n      \"callbackUrl\": \"\",\n      \"clientId\": \"\",\n      \"clientSecret\": \"\",\n      \"domain\": \"\"\n    },\n    \"cleverSettings\": {\n      \"consumerKey\": \"\",\n      \"consumerSecret\": \"\",\n      \"orgaId\": \"\",\n      \"secret\": \"\",\n      \"token\": \"\"\n    },\n    \"elasticReadsConfig\": {\n      \"clusterUri\": \"\",\n      \"headers\": {},\n      \"index\": \"\",\n      \"password\": \"\",\n      \"type\": \"\",\n      \"user\": \"\"\n    },\n    \"elasticWritesConfigs\": [\n      {}\n    ],\n    \"endlessIpAddresses\": [],\n    \"ipFiltering\": {\n      \"blacklist\": [],\n      \"whitelist\": []\n    },\n    \"limitConcurrentRequests\": false,\n    \"lines\": [],\n    \"mailerSettings\": {\n      \"apiKey\": \"\",\n      \"apiKeyPrivate\": \"\",\n      \"apiKeyPublic\": \"\",\n      \"domain\": \"\",\n      \"eu\": false,\n      \"header\": {},\n      \"type\": \"\",\n      \"url\": \"\"\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxHttp10ResponseSize\": 0,\n    \"maxLogsSize\": 0,\n    \"middleFingers\": false,\n    \"perIpThrottlingQuota\": 0,\n    \"privateAppsAuth0Config\": {},\n    \"streamEntityOnly\": false,\n    \"throttlingQuota\": 0,\n    \"u2fLoginOnly\": false,\n    \"useCircuitBreakers\": false\n  },\n  \"date\": \"\",\n  \"dateRaw\": 0,\n  \"errorTemplates\": [\n    {\n      \"messages\": {},\n      \"serviceId\": \"\",\n      \"template40x\": \"\",\n      \"template50x\": \"\",\n      \"templateBuild\": \"\",\n      \"templateMaintenance\": \"\"\n    }\n  ],\n  \"label\": \"\",\n  \"serviceDescriptors\": [\n    {\n      \"Canary\": {\n        \"enabled\": false,\n        \"root\": \"\",\n        \"targets\": [\n          {\n            \"host\": \"\",\n            \"scheme\": \"\"\n          }\n        ],\n        \"traffic\": 0\n      },\n      \"additionalHeaders\": {},\n      \"api\": {\n        \"exposeApi\": false,\n        \"openApiDescriptorUrl\": \"\"\n      },\n      \"authConfigRef\": \"\",\n      \"buildMode\": false,\n      \"chaosConfig\": {\n        \"badResponsesFaultConfig\": {\n          \"ratio\": \"\",\n          \"responses\": [\n            {\n              \"body\": \"\",\n              \"headers\": {},\n              \"status\": 0\n            }\n          ]\n        },\n        \"enabled\": false,\n        \"largeRequestFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"largeResponseFaultConfig\": {\n          \"additionalRequestSize\": 0,\n          \"ratio\": \"\"\n        },\n        \"latencyInjectionFaultConfig\": {\n          \"from\": 0,\n          \"ratio\": \"\",\n          \"to\": 0\n        }\n      },\n      \"clientConfig\": {\n        \"backoffFactor\": 0,\n        \"callTimeout\": 0,\n        \"globalTimeout\": 0,\n        \"maxErrors\": 0,\n        \"retries\": 0,\n        \"retryInitialDelay\": 0,\n        \"sampleInterval\": 0,\n        \"useCircuitBreaker\": false\n      },\n      \"clientValidatorRef\": \"\",\n      \"cors\": {\n        \"allowCredentials\": false,\n        \"allowHeaders\": [],\n        \"allowMethods\": [],\n        \"allowOrigin\": \"\",\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"exposeHeaders\": [],\n        \"maxAge\": 0\n      },\n      \"domain\": \"\",\n      \"enabled\": false,\n      \"enforceSecureCommunication\": false,\n      \"env\": \"\",\n      \"forceHttps\": false,\n      \"groups\": [],\n      \"gzip\": {\n        \"blackList\": [],\n        \"bufferSize\": 0,\n        \"chunkedThreshold\": 0,\n        \"compressionLevel\": 0,\n        \"enabled\": false,\n        \"excludedPatterns\": [],\n        \"whiteList\": []\n      },\n      \"headersVerification\": {},\n      \"healthCheck\": {\n        \"enabled\": false,\n        \"url\": \"\"\n      },\n      \"id\": \"\",\n      \"ipFiltering\": {},\n      \"jwtVerifier\": \"\",\n      \"localHost\": \"\",\n      \"localScheme\": \"\",\n      \"maintenanceMode\": false,\n      \"matchingHeaders\": {},\n      \"matchingRoot\": \"\",\n      \"metadata\": {},\n      \"name\": \"\",\n      \"overrideHost\": false,\n      \"privateApp\": false,\n      \"privatePatterns\": [],\n      \"publicPatterns\": [],\n      \"redirectToLocal\": false,\n      \"redirection\": {\n        \"code\": 0,\n        \"enabled\": false,\n        \"to\": \"\"\n      },\n      \"root\": \"\",\n      \"secComExcludedPatterns\": [],\n      \"secComSettings\": \"\",\n      \"sendOtoroshiHeadersBack\": false,\n      \"statsdConfig\": {\n        \"datadog\": false,\n        \"host\": \"\",\n        \"port\": 0\n      },\n      \"subdomain\": \"\",\n      \"targets\": [\n        {}\n      ],\n      \"transformerRef\": \"\",\n      \"userFacing\": false,\n      \"xForwardedHeaders\": false\n    }\n  ],\n  \"serviceGroups\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"simpleAdmins\": [\n    {\n      \"createdAt\": 0,\n      \"label\": \"\",\n      \"password\": \"\",\n      \"username\": \"\"\n    }\n  ],\n  \"stats\": {\n    \"calls\": 0,\n    \"dataIn\": 0,\n    \"dataOut\": 0\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/otoroshi.json";

    let payload = json!({
        "admins": (
            json!({
                "createdAt": 0,
                "label": "",
                "password": "",
                "registration": json!({}),
                "username": ""
            })
        ),
        "apiKeys": (
            json!({
                "authorizedEntities": (),
                "clientId": "",
                "clientName": "",
                "clientSecret": "",
                "dailyQuota": 0,
                "enabled": false,
                "metadata": json!({}),
                "monthlyQuota": 0,
                "throttlingQuota": 0
            })
        ),
        "appConfig": json!({}),
        "config": json!({
            "alertsEmails": (),
            "alertsWebhooks": (
                json!({
                    "headers": json!({}),
                    "url": ""
                })
            ),
            "analyticsWebhooks": (json!({})),
            "apiReadOnly": false,
            "autoLinkToDefaultGroup": false,
            "backofficeAuth0Config": json!({
                "callbackUrl": "",
                "clientId": "",
                "clientSecret": "",
                "domain": ""
            }),
            "cleverSettings": json!({
                "consumerKey": "",
                "consumerSecret": "",
                "orgaId": "",
                "secret": "",
                "token": ""
            }),
            "elasticReadsConfig": json!({
                "clusterUri": "",
                "headers": json!({}),
                "index": "",
                "password": "",
                "type": "",
                "user": ""
            }),
            "elasticWritesConfigs": (json!({})),
            "endlessIpAddresses": (),
            "ipFiltering": json!({
                "blacklist": (),
                "whitelist": ()
            }),
            "limitConcurrentRequests": false,
            "lines": (),
            "mailerSettings": json!({
                "apiKey": "",
                "apiKeyPrivate": "",
                "apiKeyPublic": "",
                "domain": "",
                "eu": false,
                "header": json!({}),
                "type": "",
                "url": ""
            }),
            "maxConcurrentRequests": 0,
            "maxHttp10ResponseSize": 0,
            "maxLogsSize": 0,
            "middleFingers": false,
            "perIpThrottlingQuota": 0,
            "privateAppsAuth0Config": json!({}),
            "streamEntityOnly": false,
            "throttlingQuota": 0,
            "u2fLoginOnly": false,
            "useCircuitBreakers": false
        }),
        "date": "",
        "dateRaw": 0,
        "errorTemplates": (
            json!({
                "messages": json!({}),
                "serviceId": "",
                "template40x": "",
                "template50x": "",
                "templateBuild": "",
                "templateMaintenance": ""
            })
        ),
        "label": "",
        "serviceDescriptors": (
            json!({
                "Canary": json!({
                    "enabled": false,
                    "root": "",
                    "targets": (
                        json!({
                            "host": "",
                            "scheme": ""
                        })
                    ),
                    "traffic": 0
                }),
                "additionalHeaders": json!({}),
                "api": json!({
                    "exposeApi": false,
                    "openApiDescriptorUrl": ""
                }),
                "authConfigRef": "",
                "buildMode": false,
                "chaosConfig": json!({
                    "badResponsesFaultConfig": json!({
                        "ratio": "",
                        "responses": (
                            json!({
                                "body": "",
                                "headers": json!({}),
                                "status": 0
                            })
                        )
                    }),
                    "enabled": false,
                    "largeRequestFaultConfig": json!({
                        "additionalRequestSize": 0,
                        "ratio": ""
                    }),
                    "largeResponseFaultConfig": json!({
                        "additionalRequestSize": 0,
                        "ratio": ""
                    }),
                    "latencyInjectionFaultConfig": json!({
                        "from": 0,
                        "ratio": "",
                        "to": 0
                    })
                }),
                "clientConfig": json!({
                    "backoffFactor": 0,
                    "callTimeout": 0,
                    "globalTimeout": 0,
                    "maxErrors": 0,
                    "retries": 0,
                    "retryInitialDelay": 0,
                    "sampleInterval": 0,
                    "useCircuitBreaker": false
                }),
                "clientValidatorRef": "",
                "cors": json!({
                    "allowCredentials": false,
                    "allowHeaders": (),
                    "allowMethods": (),
                    "allowOrigin": "",
                    "enabled": false,
                    "excludedPatterns": (),
                    "exposeHeaders": (),
                    "maxAge": 0
                }),
                "domain": "",
                "enabled": false,
                "enforceSecureCommunication": false,
                "env": "",
                "forceHttps": false,
                "groups": (),
                "gzip": json!({
                    "blackList": (),
                    "bufferSize": 0,
                    "chunkedThreshold": 0,
                    "compressionLevel": 0,
                    "enabled": false,
                    "excludedPatterns": (),
                    "whiteList": ()
                }),
                "headersVerification": json!({}),
                "healthCheck": json!({
                    "enabled": false,
                    "url": ""
                }),
                "id": "",
                "ipFiltering": json!({}),
                "jwtVerifier": "",
                "localHost": "",
                "localScheme": "",
                "maintenanceMode": false,
                "matchingHeaders": json!({}),
                "matchingRoot": "",
                "metadata": json!({}),
                "name": "",
                "overrideHost": false,
                "privateApp": false,
                "privatePatterns": (),
                "publicPatterns": (),
                "redirectToLocal": false,
                "redirection": json!({
                    "code": 0,
                    "enabled": false,
                    "to": ""
                }),
                "root": "",
                "secComExcludedPatterns": (),
                "secComSettings": "",
                "sendOtoroshiHeadersBack": false,
                "statsdConfig": json!({
                    "datadog": false,
                    "host": "",
                    "port": 0
                }),
                "subdomain": "",
                "targets": (json!({})),
                "transformerRef": "",
                "userFacing": false,
                "xForwardedHeaders": false
            })
        ),
        "serviceGroups": (
            json!({
                "description": "",
                "id": "",
                "name": ""
            })
        ),
        "simpleAdmins": (
            json!({
                "createdAt": 0,
                "label": "",
                "password": "",
                "username": ""
            })
        ),
        "stats": json!({
            "calls": 0,
            "dataIn": 0,
            "dataOut": 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}}/api/otoroshi.json \
  --header 'content-type: application/json' \
  --data '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}'

echo '{
  "admins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": {},
      "username": ""
    }
  ],
  "apiKeys": [
    {
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": {},
      "monthlyQuota": 0,
      "throttlingQuota": 0
    }
  ],
  "appConfig": {},
  "config": {
    "alertsEmails": [],
    "alertsWebhooks": [
      {
        "headers": {},
        "url": ""
      }
    ],
    "analyticsWebhooks": [
      {}
    ],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": {
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    },
    "cleverSettings": {
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    },
    "elasticReadsConfig": {
      "clusterUri": "",
      "headers": {},
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    },
    "elasticWritesConfigs": [
      {}
    ],
    "endlessIpAddresses": [],
    "ipFiltering": {
      "blacklist": [],
      "whitelist": []
    },
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": {
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": {},
      "type": "",
      "url": ""
    },
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": {},
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  },
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    {
      "messages": {},
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    }
  ],
  "label": "",
  "serviceDescriptors": [
    {
      "Canary": {
        "enabled": false,
        "root": "",
        "targets": [
          {
            "host": "",
            "scheme": ""
          }
        ],
        "traffic": 0
      },
      "additionalHeaders": {},
      "api": {
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      },
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": {
        "badResponsesFaultConfig": {
          "ratio": "",
          "responses": [
            {
              "body": "",
              "headers": {},
              "status": 0
            }
          ]
        },
        "enabled": false,
        "largeRequestFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "largeResponseFaultConfig": {
          "additionalRequestSize": 0,
          "ratio": ""
        },
        "latencyInjectionFaultConfig": {
          "from": 0,
          "ratio": "",
          "to": 0
        }
      },
      "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      },
      "clientValidatorRef": "",
      "cors": {
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      },
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      },
      "headersVerification": {},
      "healthCheck": {
        "enabled": false,
        "url": ""
      },
      "id": "",
      "ipFiltering": {},
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": {},
      "matchingRoot": "",
      "metadata": {},
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": {
        "code": 0,
        "enabled": false,
        "to": ""
      },
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": {
        "datadog": false,
        "host": "",
        "port": 0
      },
      "subdomain": "",
      "targets": [
        {}
      ],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    }
  ],
  "serviceGroups": [
    {
      "description": "",
      "id": "",
      "name": ""
    }
  ],
  "simpleAdmins": [
    {
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    }
  ],
  "stats": {
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  }
}' |  \
  http POST {{baseUrl}}/api/otoroshi.json \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "admins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "registration": {},\n      "username": ""\n    }\n  ],\n  "apiKeys": [\n    {\n      "authorizedEntities": [],\n      "clientId": "",\n      "clientName": "",\n      "clientSecret": "",\n      "dailyQuota": 0,\n      "enabled": false,\n      "metadata": {},\n      "monthlyQuota": 0,\n      "throttlingQuota": 0\n    }\n  ],\n  "appConfig": {},\n  "config": {\n    "alertsEmails": [],\n    "alertsWebhooks": [\n      {\n        "headers": {},\n        "url": ""\n      }\n    ],\n    "analyticsWebhooks": [\n      {}\n    ],\n    "apiReadOnly": false,\n    "autoLinkToDefaultGroup": false,\n    "backofficeAuth0Config": {\n      "callbackUrl": "",\n      "clientId": "",\n      "clientSecret": "",\n      "domain": ""\n    },\n    "cleverSettings": {\n      "consumerKey": "",\n      "consumerSecret": "",\n      "orgaId": "",\n      "secret": "",\n      "token": ""\n    },\n    "elasticReadsConfig": {\n      "clusterUri": "",\n      "headers": {},\n      "index": "",\n      "password": "",\n      "type": "",\n      "user": ""\n    },\n    "elasticWritesConfigs": [\n      {}\n    ],\n    "endlessIpAddresses": [],\n    "ipFiltering": {\n      "blacklist": [],\n      "whitelist": []\n    },\n    "limitConcurrentRequests": false,\n    "lines": [],\n    "mailerSettings": {\n      "apiKey": "",\n      "apiKeyPrivate": "",\n      "apiKeyPublic": "",\n      "domain": "",\n      "eu": false,\n      "header": {},\n      "type": "",\n      "url": ""\n    },\n    "maxConcurrentRequests": 0,\n    "maxHttp10ResponseSize": 0,\n    "maxLogsSize": 0,\n    "middleFingers": false,\n    "perIpThrottlingQuota": 0,\n    "privateAppsAuth0Config": {},\n    "streamEntityOnly": false,\n    "throttlingQuota": 0,\n    "u2fLoginOnly": false,\n    "useCircuitBreakers": false\n  },\n  "date": "",\n  "dateRaw": 0,\n  "errorTemplates": [\n    {\n      "messages": {},\n      "serviceId": "",\n      "template40x": "",\n      "template50x": "",\n      "templateBuild": "",\n      "templateMaintenance": ""\n    }\n  ],\n  "label": "",\n  "serviceDescriptors": [\n    {\n      "Canary": {\n        "enabled": false,\n        "root": "",\n        "targets": [\n          {\n            "host": "",\n            "scheme": ""\n          }\n        ],\n        "traffic": 0\n      },\n      "additionalHeaders": {},\n      "api": {\n        "exposeApi": false,\n        "openApiDescriptorUrl": ""\n      },\n      "authConfigRef": "",\n      "buildMode": false,\n      "chaosConfig": {\n        "badResponsesFaultConfig": {\n          "ratio": "",\n          "responses": [\n            {\n              "body": "",\n              "headers": {},\n              "status": 0\n            }\n          ]\n        },\n        "enabled": false,\n        "largeRequestFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "largeResponseFaultConfig": {\n          "additionalRequestSize": 0,\n          "ratio": ""\n        },\n        "latencyInjectionFaultConfig": {\n          "from": 0,\n          "ratio": "",\n          "to": 0\n        }\n      },\n      "clientConfig": {\n        "backoffFactor": 0,\n        "callTimeout": 0,\n        "globalTimeout": 0,\n        "maxErrors": 0,\n        "retries": 0,\n        "retryInitialDelay": 0,\n        "sampleInterval": 0,\n        "useCircuitBreaker": false\n      },\n      "clientValidatorRef": "",\n      "cors": {\n        "allowCredentials": false,\n        "allowHeaders": [],\n        "allowMethods": [],\n        "allowOrigin": "",\n        "enabled": false,\n        "excludedPatterns": [],\n        "exposeHeaders": [],\n        "maxAge": 0\n      },\n      "domain": "",\n      "enabled": false,\n      "enforceSecureCommunication": false,\n      "env": "",\n      "forceHttps": false,\n      "groups": [],\n      "gzip": {\n        "blackList": [],\n        "bufferSize": 0,\n        "chunkedThreshold": 0,\n        "compressionLevel": 0,\n        "enabled": false,\n        "excludedPatterns": [],\n        "whiteList": []\n      },\n      "headersVerification": {},\n      "healthCheck": {\n        "enabled": false,\n        "url": ""\n      },\n      "id": "",\n      "ipFiltering": {},\n      "jwtVerifier": "",\n      "localHost": "",\n      "localScheme": "",\n      "maintenanceMode": false,\n      "matchingHeaders": {},\n      "matchingRoot": "",\n      "metadata": {},\n      "name": "",\n      "overrideHost": false,\n      "privateApp": false,\n      "privatePatterns": [],\n      "publicPatterns": [],\n      "redirectToLocal": false,\n      "redirection": {\n        "code": 0,\n        "enabled": false,\n        "to": ""\n      },\n      "root": "",\n      "secComExcludedPatterns": [],\n      "secComSettings": "",\n      "sendOtoroshiHeadersBack": false,\n      "statsdConfig": {\n        "datadog": false,\n        "host": "",\n        "port": 0\n      },\n      "subdomain": "",\n      "targets": [\n        {}\n      ],\n      "transformerRef": "",\n      "userFacing": false,\n      "xForwardedHeaders": false\n    }\n  ],\n  "serviceGroups": [\n    {\n      "description": "",\n      "id": "",\n      "name": ""\n    }\n  ],\n  "simpleAdmins": [\n    {\n      "createdAt": 0,\n      "label": "",\n      "password": "",\n      "username": ""\n    }\n  ],\n  "stats": {\n    "calls": 0,\n    "dataIn": 0,\n    "dataOut": 0\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/otoroshi.json

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "admins": [
    [
      "createdAt": 0,
      "label": "",
      "password": "",
      "registration": [],
      "username": ""
    ]
  ],
  "apiKeys": [
    [
      "authorizedEntities": [],
      "clientId": "",
      "clientName": "",
      "clientSecret": "",
      "dailyQuota": 0,
      "enabled": false,
      "metadata": [],
      "monthlyQuota": 0,
      "throttlingQuota": 0
    ]
  ],
  "appConfig": [],
  "config": [
    "alertsEmails": [],
    "alertsWebhooks": [
      [
        "headers": [],
        "url": ""
      ]
    ],
    "analyticsWebhooks": [[]],
    "apiReadOnly": false,
    "autoLinkToDefaultGroup": false,
    "backofficeAuth0Config": [
      "callbackUrl": "",
      "clientId": "",
      "clientSecret": "",
      "domain": ""
    ],
    "cleverSettings": [
      "consumerKey": "",
      "consumerSecret": "",
      "orgaId": "",
      "secret": "",
      "token": ""
    ],
    "elasticReadsConfig": [
      "clusterUri": "",
      "headers": [],
      "index": "",
      "password": "",
      "type": "",
      "user": ""
    ],
    "elasticWritesConfigs": [[]],
    "endlessIpAddresses": [],
    "ipFiltering": [
      "blacklist": [],
      "whitelist": []
    ],
    "limitConcurrentRequests": false,
    "lines": [],
    "mailerSettings": [
      "apiKey": "",
      "apiKeyPrivate": "",
      "apiKeyPublic": "",
      "domain": "",
      "eu": false,
      "header": [],
      "type": "",
      "url": ""
    ],
    "maxConcurrentRequests": 0,
    "maxHttp10ResponseSize": 0,
    "maxLogsSize": 0,
    "middleFingers": false,
    "perIpThrottlingQuota": 0,
    "privateAppsAuth0Config": [],
    "streamEntityOnly": false,
    "throttlingQuota": 0,
    "u2fLoginOnly": false,
    "useCircuitBreakers": false
  ],
  "date": "",
  "dateRaw": 0,
  "errorTemplates": [
    [
      "messages": [],
      "serviceId": "",
      "template40x": "",
      "template50x": "",
      "templateBuild": "",
      "templateMaintenance": ""
    ]
  ],
  "label": "",
  "serviceDescriptors": [
    [
      "Canary": [
        "enabled": false,
        "root": "",
        "targets": [
          [
            "host": "",
            "scheme": ""
          ]
        ],
        "traffic": 0
      ],
      "additionalHeaders": [],
      "api": [
        "exposeApi": false,
        "openApiDescriptorUrl": ""
      ],
      "authConfigRef": "",
      "buildMode": false,
      "chaosConfig": [
        "badResponsesFaultConfig": [
          "ratio": "",
          "responses": [
            [
              "body": "",
              "headers": [],
              "status": 0
            ]
          ]
        ],
        "enabled": false,
        "largeRequestFaultConfig": [
          "additionalRequestSize": 0,
          "ratio": ""
        ],
        "largeResponseFaultConfig": [
          "additionalRequestSize": 0,
          "ratio": ""
        ],
        "latencyInjectionFaultConfig": [
          "from": 0,
          "ratio": "",
          "to": 0
        ]
      ],
      "clientConfig": [
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": false
      ],
      "clientValidatorRef": "",
      "cors": [
        "allowCredentials": false,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": false,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
      ],
      "domain": "",
      "enabled": false,
      "enforceSecureCommunication": false,
      "env": "",
      "forceHttps": false,
      "groups": [],
      "gzip": [
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": false,
        "excludedPatterns": [],
        "whiteList": []
      ],
      "headersVerification": [],
      "healthCheck": [
        "enabled": false,
        "url": ""
      ],
      "id": "",
      "ipFiltering": [],
      "jwtVerifier": "",
      "localHost": "",
      "localScheme": "",
      "maintenanceMode": false,
      "matchingHeaders": [],
      "matchingRoot": "",
      "metadata": [],
      "name": "",
      "overrideHost": false,
      "privateApp": false,
      "privatePatterns": [],
      "publicPatterns": [],
      "redirectToLocal": false,
      "redirection": [
        "code": 0,
        "enabled": false,
        "to": ""
      ],
      "root": "",
      "secComExcludedPatterns": [],
      "secComSettings": "",
      "sendOtoroshiHeadersBack": false,
      "statsdConfig": [
        "datadog": false,
        "host": "",
        "port": 0
      ],
      "subdomain": "",
      "targets": [[]],
      "transformerRef": "",
      "userFacing": false,
      "xForwardedHeaders": false
    ]
  ],
  "serviceGroups": [
    [
      "description": "",
      "id": "",
      "name": ""
    ]
  ],
  "simpleAdmins": [
    [
      "createdAt": 0,
      "label": "",
      "password": "",
      "username": ""
    ]
  ],
  "stats": [
    "calls": 0,
    "dataIn": 0,
    "dataOut": 0
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/otoroshi.json")! 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

{
  "done": true
}

POST Create one global JWT verifiers

{{baseUrl}}/api/verifiers

BODY json

{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/verifiers");

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  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/verifiers" {:content-type :json
                                                          :form-params {:algoSettings ""
                                                                        :desc ""
                                                                        :enabled false
                                                                        :id ""
                                                                        :name ""
                                                                        :source ""
                                                                        :strategy ""
                                                                        :strict false}})

require "http/client"

url = "{{baseUrl}}/api/verifiers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/verifiers"),
    Content = new StringContent("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/verifiers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/verifiers"

	payload := strings.NewReader("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/verifiers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 137

{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/verifiers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/verifiers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/verifiers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/verifiers")
  .header("content-type", "application/json")
  .body("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
  .asString();

const data = JSON.stringify({
  algoSettings: '',
  desc: '',
  enabled: false,
  id: '',
  name: '',
  source: '',
  strategy: '',
  strict: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/verifiers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/verifiers',
  headers: {'content-type': 'application/json'},
  data: {
    algoSettings: '',
    desc: '',
    enabled: false,
    id: '',
    name: '',
    source: '',
    strategy: '',
    strict: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/verifiers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"algoSettings":"","desc":"","enabled":false,"id":"","name":"","source":"","strategy":"","strict":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/verifiers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "algoSettings": "",\n  "desc": "",\n  "enabled": false,\n  "id": "",\n  "name": "",\n  "source": "",\n  "strategy": "",\n  "strict": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/verifiers")
  .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/api/verifiers',
  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({
  algoSettings: '',
  desc: '',
  enabled: false,
  id: '',
  name: '',
  source: '',
  strategy: '',
  strict: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/verifiers',
  headers: {'content-type': 'application/json'},
  body: {
    algoSettings: '',
    desc: '',
    enabled: false,
    id: '',
    name: '',
    source: '',
    strategy: '',
    strict: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/verifiers');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  algoSettings: '',
  desc: '',
  enabled: false,
  id: '',
  name: '',
  source: '',
  strategy: '',
  strict: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/verifiers',
  headers: {'content-type': 'application/json'},
  data: {
    algoSettings: '',
    desc: '',
    enabled: false,
    id: '',
    name: '',
    source: '',
    strategy: '',
    strict: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/verifiers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"algoSettings":"","desc":"","enabled":false,"id":"","name":"","source":"","strategy":"","strict":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"algoSettings": @"",
                              @"desc": @"",
                              @"enabled": @NO,
                              @"id": @"",
                              @"name": @"",
                              @"source": @"",
                              @"strategy": @"",
                              @"strict": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/verifiers"]
                                                       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}}/api/verifiers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/verifiers",
  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([
    'algoSettings' => '',
    'desc' => '',
    'enabled' => null,
    'id' => '',
    'name' => '',
    'source' => '',
    'strategy' => '',
    'strict' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/verifiers', [
  'body' => '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/verifiers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'algoSettings' => '',
  'desc' => '',
  'enabled' => null,
  'id' => '',
  'name' => '',
  'source' => '',
  'strategy' => '',
  'strict' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'algoSettings' => '',
  'desc' => '',
  'enabled' => null,
  'id' => '',
  'name' => '',
  'source' => '',
  'strategy' => '',
  'strict' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/verifiers');
$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}}/api/verifiers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/verifiers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/verifiers", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/verifiers"

payload = {
    "algoSettings": "",
    "desc": "",
    "enabled": False,
    "id": "",
    "name": "",
    "source": "",
    "strategy": "",
    "strict": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/verifiers"

payload <- "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/verifiers")

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  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/verifiers') do |req|
  req.body = "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/verifiers";

    let payload = json!({
        "algoSettings": "",
        "desc": "",
        "enabled": false,
        "id": "",
        "name": "",
        "source": "",
        "strategy": "",
        "strict": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/verifiers \
  --header 'content-type: application/json' \
  --data '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}'

echo '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}' |  \
  http POST {{baseUrl}}/api/verifiers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "algoSettings": "",\n  "desc": "",\n  "enabled": false,\n  "id": "",\n  "name": "",\n  "source": "",\n  "strategy": "",\n  "strict": false\n}' \
  --output-document \
  - {{baseUrl}}/api/verifiers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/verifiers")! 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

{
  "desc": "a string value",
  "enabled": true,
  "id": "a string value",
  "name": "a string value",
  "strict": true
}

DELETE Delete one global JWT verifiers

{{baseUrl}}/api/verifiers/:verifierId

QUERY PARAMS

verifierId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/verifiers/:verifierId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/verifiers/:verifierId")

require "http/client"

url = "{{baseUrl}}/api/verifiers/:verifierId"

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}}/api/verifiers/:verifierId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/verifiers/:verifierId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/verifiers/:verifierId"

	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/api/verifiers/:verifierId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/verifiers/:verifierId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/verifiers/:verifierId"))
    .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}}/api/verifiers/:verifierId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/verifiers/:verifierId")
  .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}}/api/verifiers/:verifierId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/verifiers/:verifierId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/verifiers/:verifierId';
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}}/api/verifiers/:verifierId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/verifiers/:verifierId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/verifiers/:verifierId',
  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}}/api/verifiers/:verifierId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/verifiers/:verifierId');

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}}/api/verifiers/:verifierId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/verifiers/:verifierId';
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}}/api/verifiers/:verifierId"]
                                                       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}}/api/verifiers/:verifierId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/verifiers/:verifierId",
  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}}/api/verifiers/:verifierId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/verifiers/:verifierId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/verifiers/:verifierId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/verifiers/:verifierId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/verifiers/:verifierId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/verifiers/:verifierId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/verifiers/:verifierId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/verifiers/:verifierId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/verifiers/:verifierId")

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/api/verifiers/:verifierId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/verifiers/:verifierId";

    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}}/api/verifiers/:verifierId

http DELETE {{baseUrl}}/api/verifiers/:verifierId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/verifiers/:verifierId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/verifiers/:verifierId")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get all global JWT verifiers

{{baseUrl}}/api/verifiers

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/verifiers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/verifiers")

require "http/client"

url = "{{baseUrl}}/api/verifiers"

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}}/api/verifiers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/verifiers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/verifiers"

	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/api/verifiers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/verifiers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/verifiers"))
    .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}}/api/verifiers")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/verifiers")
  .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}}/api/verifiers');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/verifiers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/verifiers';
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}}/api/verifiers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/verifiers")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/verifiers',
  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}}/api/verifiers'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/verifiers');

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}}/api/verifiers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/verifiers';
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}}/api/verifiers"]
                                                       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}}/api/verifiers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/verifiers",
  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}}/api/verifiers');

echo $response->getBody();

setUrl('{{baseUrl}}/api/verifiers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/verifiers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/verifiers' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/verifiers' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/verifiers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/verifiers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/verifiers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/verifiers")

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/api/verifiers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/verifiers";

    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}}/api/verifiers

http GET {{baseUrl}}/api/verifiers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/verifiers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/verifiers")! 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

[
  {
    "desc": "a string value",
    "enabled": true,
    "id": "a string value",
    "name": "a string value",
    "strict": true
  }
]

GET Get one global JWT verifiers

{{baseUrl}}/api/verifiers/:verifierId

QUERY PARAMS

verifierId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/verifiers/:verifierId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/verifiers/:verifierId")

require "http/client"

url = "{{baseUrl}}/api/verifiers/:verifierId"

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}}/api/verifiers/:verifierId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/verifiers/:verifierId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/verifiers/:verifierId"

	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/api/verifiers/:verifierId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/verifiers/:verifierId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/verifiers/:verifierId"))
    .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}}/api/verifiers/:verifierId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/verifiers/:verifierId")
  .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}}/api/verifiers/:verifierId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/verifiers/:verifierId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/verifiers/:verifierId';
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}}/api/verifiers/:verifierId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/verifiers/:verifierId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/verifiers/:verifierId',
  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}}/api/verifiers/:verifierId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/verifiers/:verifierId');

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}}/api/verifiers/:verifierId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/verifiers/:verifierId';
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}}/api/verifiers/:verifierId"]
                                                       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}}/api/verifiers/:verifierId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/verifiers/:verifierId",
  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}}/api/verifiers/:verifierId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/verifiers/:verifierId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/verifiers/:verifierId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/verifiers/:verifierId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/verifiers/:verifierId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/verifiers/:verifierId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/verifiers/:verifierId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/verifiers/:verifierId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/verifiers/:verifierId")

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/api/verifiers/:verifierId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/verifiers/:verifierId";

    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}}/api/verifiers/:verifierId

http GET {{baseUrl}}/api/verifiers/:verifierId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/verifiers/:verifierId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/verifiers/:verifierId")! 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

{
  "desc": "a string value",
  "enabled": true,
  "id": "a string value",
  "name": "a string value",
  "strict": true
}

PUT Update one global JWT verifiers (PUT)

{{baseUrl}}/api/verifiers/:verifierId

QUERY PARAMS

verifierId

BODY json

{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/verifiers/:verifierId");

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  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/verifiers/:verifierId" {:content-type :json
                                                                     :form-params {:algoSettings ""
                                                                                   :desc ""
                                                                                   :enabled false
                                                                                   :id ""
                                                                                   :name ""
                                                                                   :source ""
                                                                                   :strategy ""
                                                                                   :strict false}})

require "http/client"

url = "{{baseUrl}}/api/verifiers/:verifierId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\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}}/api/verifiers/:verifierId"),
    Content = new StringContent("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/verifiers/:verifierId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/verifiers/:verifierId"

	payload := strings.NewReader("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\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/api/verifiers/:verifierId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 137

{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/verifiers/:verifierId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/verifiers/:verifierId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/verifiers/:verifierId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/verifiers/:verifierId")
  .header("content-type", "application/json")
  .body("{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
  .asString();

const data = JSON.stringify({
  algoSettings: '',
  desc: '',
  enabled: false,
  id: '',
  name: '',
  source: '',
  strategy: '',
  strict: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/verifiers/:verifierId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  headers: {'content-type': 'application/json'},
  data: {
    algoSettings: '',
    desc: '',
    enabled: false,
    id: '',
    name: '',
    source: '',
    strategy: '',
    strict: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/verifiers/:verifierId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"algoSettings":"","desc":"","enabled":false,"id":"","name":"","source":"","strategy":"","strict":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "algoSettings": "",\n  "desc": "",\n  "enabled": false,\n  "id": "",\n  "name": "",\n  "source": "",\n  "strategy": "",\n  "strict": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/verifiers/:verifierId")
  .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/api/verifiers/:verifierId',
  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({
  algoSettings: '',
  desc: '',
  enabled: false,
  id: '',
  name: '',
  source: '',
  strategy: '',
  strict: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  headers: {'content-type': 'application/json'},
  body: {
    algoSettings: '',
    desc: '',
    enabled: false,
    id: '',
    name: '',
    source: '',
    strategy: '',
    strict: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/verifiers/:verifierId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  algoSettings: '',
  desc: '',
  enabled: false,
  id: '',
  name: '',
  source: '',
  strategy: '',
  strict: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  headers: {'content-type': 'application/json'},
  data: {
    algoSettings: '',
    desc: '',
    enabled: false,
    id: '',
    name: '',
    source: '',
    strategy: '',
    strict: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/verifiers/:verifierId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"algoSettings":"","desc":"","enabled":false,"id":"","name":"","source":"","strategy":"","strict":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"algoSettings": @"",
                              @"desc": @"",
                              @"enabled": @NO,
                              @"id": @"",
                              @"name": @"",
                              @"source": @"",
                              @"strategy": @"",
                              @"strict": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/verifiers/:verifierId"]
                                                       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}}/api/verifiers/:verifierId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/verifiers/:verifierId",
  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([
    'algoSettings' => '',
    'desc' => '',
    'enabled' => null,
    'id' => '',
    'name' => '',
    'source' => '',
    'strategy' => '',
    'strict' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/verifiers/:verifierId', [
  'body' => '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/verifiers/:verifierId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'algoSettings' => '',
  'desc' => '',
  'enabled' => null,
  'id' => '',
  'name' => '',
  'source' => '',
  'strategy' => '',
  'strict' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'algoSettings' => '',
  'desc' => '',
  'enabled' => null,
  'id' => '',
  'name' => '',
  'source' => '',
  'strategy' => '',
  'strict' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/verifiers/:verifierId');
$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}}/api/verifiers/:verifierId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/verifiers/:verifierId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/verifiers/:verifierId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/verifiers/:verifierId"

payload = {
    "algoSettings": "",
    "desc": "",
    "enabled": False,
    "id": "",
    "name": "",
    "source": "",
    "strategy": "",
    "strict": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/verifiers/:verifierId"

payload <- "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\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}}/api/verifiers/:verifierId")

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  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/api/verifiers/:verifierId') do |req|
  req.body = "{\n  \"algoSettings\": \"\",\n  \"desc\": \"\",\n  \"enabled\": false,\n  \"id\": \"\",\n  \"name\": \"\",\n  \"source\": \"\",\n  \"strategy\": \"\",\n  \"strict\": false\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}}/api/verifiers/:verifierId";

    let payload = json!({
        "algoSettings": "",
        "desc": "",
        "enabled": false,
        "id": "",
        "name": "",
        "source": "",
        "strategy": "",
        "strict": false
    });

    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}}/api/verifiers/:verifierId \
  --header 'content-type: application/json' \
  --data '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}'

echo '{
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
}' |  \
  http PUT {{baseUrl}}/api/verifiers/:verifierId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "algoSettings": "",\n  "desc": "",\n  "enabled": false,\n  "id": "",\n  "name": "",\n  "source": "",\n  "strategy": "",\n  "strict": false\n}' \
  --output-document \
  - {{baseUrl}}/api/verifiers/:verifierId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "algoSettings": "",
  "desc": "",
  "enabled": false,
  "id": "",
  "name": "",
  "source": "",
  "strategy": "",
  "strict": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/verifiers/:verifierId")! 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

{
  "desc": "a string value",
  "enabled": true,
  "id": "a string value",
  "name": "a string value",
  "strict": true
}

PATCH Update one global JWT verifiers

{{baseUrl}}/api/verifiers/:verifierId

QUERY PARAMS

verifierId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/verifiers/:verifierId");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/verifiers/:verifierId" {:content-type :json
                                                                       :form-params [{:op ""
                                                                                      :path ""
                                                                                      :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/verifiers/:verifierId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/verifiers/:verifierId"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/verifiers/:verifierId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/verifiers/:verifierId"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/verifiers/:verifierId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/verifiers/:verifierId")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/verifiers/:verifierId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/verifiers/:verifierId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/verifiers/:verifierId")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/verifiers/:verifierId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/verifiers/:verifierId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/verifiers/:verifierId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/verifiers/:verifierId',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/verifiers/:verifierId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/verifiers/:verifierId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/verifiers/:verifierId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/verifiers/:verifierId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/verifiers/:verifierId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/verifiers/:verifierId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/verifiers/:verifierId', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/verifiers/:verifierId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/verifiers/:verifierId');
$request->setRequestMethod('PATCH');
$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}}/api/verifiers/:verifierId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/verifiers/:verifierId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/verifiers/:verifierId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/verifiers/:verifierId"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/verifiers/:verifierId"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/verifiers/:verifierId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/verifiers/:verifierId') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/verifiers/:verifierId";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/verifiers/:verifierId \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/verifiers/:verifierId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/verifiers/:verifierId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/verifiers/:verifierId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "desc": "a string value",
  "enabled": true,
  "id": "a string value",
  "name": "a string value",
  "strict": true
}

POST Compile a script

{{baseUrl}}/api/scripts/_compile

BODY json

{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/scripts/_compile");

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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/scripts/_compile" {:content-type :json
                                                                 :form-params {:code {}
                                                                               :desc {}
                                                                               :id ""
                                                                               :name ""}})

require "http/client"

url = "{{baseUrl}}/api/scripts/_compile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/_compile"),
    Content = new StringContent("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/_compile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/scripts/_compile"

	payload := strings.NewReader("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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/api/scripts/_compile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/scripts/_compile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/scripts/_compile"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/scripts/_compile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/scripts/_compile")
  .header("content-type", "application/json")
  .body("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  code: {},
  desc: {},
  id: '',
  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}}/api/scripts/_compile');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/scripts/_compile',
  headers: {'content-type': 'application/json'},
  data: {code: {}, desc: {}, id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/scripts/_compile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":{},"desc":{},"id":"","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}}/api/scripts/_compile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": {},\n  "desc": {},\n  "id": "",\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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/scripts/_compile")
  .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/api/scripts/_compile',
  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({code: {}, desc: {}, id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/scripts/_compile',
  headers: {'content-type': 'application/json'},
  body: {code: {}, desc: {}, id: '', 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}}/api/scripts/_compile');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: {},
  desc: {},
  id: '',
  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}}/api/scripts/_compile',
  headers: {'content-type': 'application/json'},
  data: {code: {}, desc: {}, id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/scripts/_compile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":{},"desc":{},"id":"","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 = @{ @"code": @{  },
                              @"desc": @{  },
                              @"id": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/scripts/_compile"]
                                                       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}}/api/scripts/_compile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/scripts/_compile",
  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([
    'code' => [
        
    ],
    'desc' => [
        
    ],
    'id' => '',
    '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}}/api/scripts/_compile', [
  'body' => '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/scripts/_compile');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => [
    
  ],
  'desc' => [
    
  ],
  'id' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => [
    
  ],
  'desc' => [
    
  ],
  'id' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/scripts/_compile');
$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}}/api/scripts/_compile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/scripts/_compile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/scripts/_compile", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/scripts/_compile"

payload = {
    "code": {},
    "desc": {},
    "id": "",
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/scripts/_compile"

payload <- "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/_compile")

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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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/api/scripts/_compile') do |req|
  req.body = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/_compile";

    let payload = json!({
        "code": json!({}),
        "desc": json!({}),
        "id": "",
        "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}}/api/scripts/_compile \
  --header 'content-type: application/json' \
  --data '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

echo '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/api/scripts/_compile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": {},\n  "desc": {},\n  "id": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/scripts/_compile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "code": [],
  "desc": [],
  "id": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/scripts/_compile")! 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

{
  "done": true,
  "error": {
    "column": "a string value",
    "file": {
      "key": "value"
    },
    "line": "a string value",
    "message": {
      "key": "value"
    },
    "rawMessage": {
      "key": "value"
    }
  }
}

POST Create a new script

{{baseUrl}}/api/scripts

BODY json

{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/scripts");

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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/scripts" {:content-type :json
                                                        :form-params {:code {}
                                                                      :desc {}
                                                                      :id ""
                                                                      :name ""}})

require "http/client"

url = "{{baseUrl}}/api/scripts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts"),
    Content = new StringContent("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/scripts"

	payload := strings.NewReader("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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/api/scripts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/scripts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/scripts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/scripts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/scripts")
  .header("content-type", "application/json")
  .body("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  code: {},
  desc: {},
  id: '',
  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}}/api/scripts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/scripts',
  headers: {'content-type': 'application/json'},
  data: {code: {}, desc: {}, id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/scripts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":{},"desc":{},"id":"","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}}/api/scripts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": {},\n  "desc": {},\n  "id": "",\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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/scripts")
  .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/api/scripts',
  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({code: {}, desc: {}, id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/scripts',
  headers: {'content-type': 'application/json'},
  body: {code: {}, desc: {}, id: '', 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}}/api/scripts');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: {},
  desc: {},
  id: '',
  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}}/api/scripts',
  headers: {'content-type': 'application/json'},
  data: {code: {}, desc: {}, id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/scripts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":{},"desc":{},"id":"","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 = @{ @"code": @{  },
                              @"desc": @{  },
                              @"id": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/scripts"]
                                                       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}}/api/scripts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/scripts",
  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([
    'code' => [
        
    ],
    'desc' => [
        
    ],
    'id' => '',
    '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}}/api/scripts', [
  'body' => '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/scripts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => [
    
  ],
  'desc' => [
    
  ],
  'id' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => [
    
  ],
  'desc' => [
    
  ],
  'id' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/scripts');
$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}}/api/scripts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/scripts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/scripts", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/scripts"

payload = {
    "code": {},
    "desc": {},
    "id": "",
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/scripts"

payload <- "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts")

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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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/api/scripts') do |req|
  req.body = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts";

    let payload = json!({
        "code": json!({}),
        "desc": json!({}),
        "id": "",
        "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}}/api/scripts \
  --header 'content-type: application/json' \
  --data '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

echo '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/api/scripts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": {},\n  "desc": {},\n  "id": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/scripts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "code": [],
  "desc": [],
  "id": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/scripts")! 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

{
  "code": {
    "key": "value"
  },
  "desc": {
    "key": "value"
  },
  "id": "a string value",
  "name": "a string value"
}

DELETE Delete a script

{{baseUrl}}/api/scripts/:scriptId

QUERY PARAMS

scriptId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/scripts/:scriptId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/scripts/:scriptId")

require "http/client"

url = "{{baseUrl}}/api/scripts/:scriptId"

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}}/api/scripts/:scriptId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/scripts/:scriptId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/scripts/:scriptId"

	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/api/scripts/:scriptId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/scripts/:scriptId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/scripts/:scriptId"))
    .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}}/api/scripts/:scriptId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/scripts/:scriptId")
  .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}}/api/scripts/:scriptId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/scripts/:scriptId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/scripts/:scriptId';
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}}/api/scripts/:scriptId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/scripts/:scriptId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/scripts/:scriptId',
  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}}/api/scripts/:scriptId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/scripts/:scriptId');

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}}/api/scripts/:scriptId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/scripts/:scriptId';
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}}/api/scripts/:scriptId"]
                                                       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}}/api/scripts/:scriptId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/scripts/:scriptId",
  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}}/api/scripts/:scriptId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/scripts/:scriptId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/scripts/:scriptId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/scripts/:scriptId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/scripts/:scriptId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/scripts/:scriptId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/scripts/:scriptId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/scripts/:scriptId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/scripts/:scriptId")

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/api/scripts/:scriptId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/scripts/:scriptId";

    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}}/api/scripts/:scriptId

http DELETE {{baseUrl}}/api/scripts/:scriptId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/scripts/:scriptId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/scripts/:scriptId")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get a script

{{baseUrl}}/api/scripts/:scriptId

QUERY PARAMS

scriptId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/scripts/:scriptId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/scripts/:scriptId")

require "http/client"

url = "{{baseUrl}}/api/scripts/:scriptId"

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}}/api/scripts/:scriptId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/scripts/:scriptId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/scripts/:scriptId"

	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/api/scripts/:scriptId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/scripts/:scriptId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/scripts/:scriptId"))
    .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}}/api/scripts/:scriptId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/scripts/:scriptId")
  .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}}/api/scripts/:scriptId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/scripts/:scriptId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/scripts/:scriptId';
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}}/api/scripts/:scriptId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/scripts/:scriptId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/scripts/:scriptId',
  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}}/api/scripts/:scriptId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/scripts/:scriptId');

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}}/api/scripts/:scriptId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/scripts/:scriptId';
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}}/api/scripts/:scriptId"]
                                                       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}}/api/scripts/:scriptId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/scripts/:scriptId",
  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}}/api/scripts/:scriptId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/scripts/:scriptId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/scripts/:scriptId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/scripts/:scriptId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/scripts/:scriptId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/scripts/:scriptId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/scripts/:scriptId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/scripts/:scriptId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/scripts/:scriptId")

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/api/scripts/:scriptId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/scripts/:scriptId";

    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}}/api/scripts/:scriptId

http GET {{baseUrl}}/api/scripts/:scriptId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/scripts/:scriptId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/scripts/:scriptId")! 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

{
  "code": {
    "key": "value"
  },
  "desc": {
    "key": "value"
  },
  "id": "a string value",
  "name": "a string value"
}

GET Get all scripts

{{baseUrl}}/api/scripts

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/scripts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/scripts")

require "http/client"

url = "{{baseUrl}}/api/scripts"

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}}/api/scripts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/scripts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/scripts"

	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/api/scripts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/scripts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/scripts"))
    .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}}/api/scripts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/scripts")
  .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}}/api/scripts');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/scripts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/scripts';
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}}/api/scripts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/scripts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/scripts',
  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}}/api/scripts'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/scripts');

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}}/api/scripts'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/scripts';
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}}/api/scripts"]
                                                       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}}/api/scripts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/scripts",
  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}}/api/scripts');

echo $response->getBody();

setUrl('{{baseUrl}}/api/scripts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/scripts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/scripts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/scripts' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/scripts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/scripts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/scripts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/scripts")

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/api/scripts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/scripts";

    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}}/api/scripts

http GET {{baseUrl}}/api/scripts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/scripts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/scripts")! 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

[
  {
    "code": {
      "key": "value"
    },
    "desc": {
      "key": "value"
    },
    "id": "a string value",
    "name": "a string value"
  }
]

PATCH Update a script with a diff

{{baseUrl}}/api/scripts/:scriptId

QUERY PARAMS

scriptId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/scripts/:scriptId");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/scripts/:scriptId" {:content-type :json
                                                                   :form-params [{:op ""
                                                                                  :path ""
                                                                                  :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/scripts/:scriptId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/scripts/:scriptId"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/scripts/:scriptId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/scripts/:scriptId"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/scripts/:scriptId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/scripts/:scriptId")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/scripts/:scriptId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/scripts/:scriptId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/scripts/:scriptId")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/scripts/:scriptId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/scripts/:scriptId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/scripts/:scriptId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/scripts/:scriptId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/scripts/:scriptId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/scripts/:scriptId',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/scripts/:scriptId',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/scripts/:scriptId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/scripts/:scriptId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/scripts/:scriptId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/scripts/:scriptId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/scripts/:scriptId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/scripts/:scriptId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/scripts/:scriptId', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/scripts/:scriptId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/scripts/:scriptId');
$request->setRequestMethod('PATCH');
$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}}/api/scripts/:scriptId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/scripts/:scriptId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/scripts/:scriptId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/scripts/:scriptId"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/scripts/:scriptId"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/scripts/:scriptId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/scripts/:scriptId') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/scripts/:scriptId";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/scripts/:scriptId \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/scripts/:scriptId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/scripts/:scriptId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/scripts/:scriptId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "code": {
    "key": "value"
  },
  "desc": {
    "key": "value"
  },
  "id": "a string value",
  "name": "a string value"
}

PUT Update a script

{{baseUrl}}/api/scripts/:scriptId

QUERY PARAMS

scriptId

BODY json

{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/scripts/:scriptId");

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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/scripts/:scriptId" {:content-type :json
                                                                 :form-params {:code {}
                                                                               :desc {}
                                                                               :id ""
                                                                               :name ""}})

require "http/client"

url = "{{baseUrl}}/api/scripts/:scriptId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/:scriptId"),
    Content = new StringContent("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/:scriptId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/scripts/:scriptId"

	payload := strings.NewReader("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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/api/scripts/:scriptId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/scripts/:scriptId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/scripts/:scriptId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/scripts/:scriptId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/scripts/:scriptId")
  .header("content-type", "application/json")
  .body("{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  code: {},
  desc: {},
  id: '',
  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}}/api/scripts/:scriptId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/scripts/:scriptId',
  headers: {'content-type': 'application/json'},
  data: {code: {}, desc: {}, id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/scripts/:scriptId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"code":{},"desc":{},"id":"","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}}/api/scripts/:scriptId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": {},\n  "desc": {},\n  "id": "",\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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/scripts/:scriptId")
  .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/api/scripts/:scriptId',
  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({code: {}, desc: {}, id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/scripts/:scriptId',
  headers: {'content-type': 'application/json'},
  body: {code: {}, desc: {}, id: '', 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}}/api/scripts/:scriptId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: {},
  desc: {},
  id: '',
  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}}/api/scripts/:scriptId',
  headers: {'content-type': 'application/json'},
  data: {code: {}, desc: {}, id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/scripts/:scriptId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"code":{},"desc":{},"id":"","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 = @{ @"code": @{  },
                              @"desc": @{  },
                              @"id": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/scripts/:scriptId"]
                                                       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}}/api/scripts/:scriptId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/scripts/:scriptId",
  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([
    'code' => [
        
    ],
    'desc' => [
        
    ],
    'id' => '',
    '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}}/api/scripts/:scriptId', [
  'body' => '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/scripts/:scriptId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => [
    
  ],
  'desc' => [
    
  ],
  'id' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => [
    
  ],
  'desc' => [
    
  ],
  'id' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/scripts/:scriptId');
$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}}/api/scripts/:scriptId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/scripts/:scriptId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/scripts/:scriptId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/scripts/:scriptId"

payload = {
    "code": {},
    "desc": {},
    "id": "",
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/scripts/:scriptId"

payload <- "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/:scriptId")

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  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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/api/scripts/:scriptId') do |req|
  req.body = "{\n  \"code\": {},\n  \"desc\": {},\n  \"id\": \"\",\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}}/api/scripts/:scriptId";

    let payload = json!({
        "code": json!({}),
        "desc": json!({}),
        "id": "",
        "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}}/api/scripts/:scriptId \
  --header 'content-type: application/json' \
  --data '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}'

echo '{
  "code": {},
  "desc": {},
  "id": "",
  "name": ""
}' |  \
  http PUT {{baseUrl}}/api/scripts/:scriptId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": {},\n  "desc": {},\n  "id": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/scripts/:scriptId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "code": [],
  "desc": [],
  "id": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/scripts/:scriptId")! 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

{
  "code": {
    "key": "value"
  },
  "desc": {
    "key": "value"
  },
  "id": "a string value",
  "name": "a string value"
}

POST Add a target to a service descriptor

{{baseUrl}}/api/services/:serviceId/targets

QUERY PARAMS

serviceId

BODY json

{
  "host": "",
  "scheme": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/targets");

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  \"host\": \"\",\n  \"scheme\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/services/:serviceId/targets" {:content-type :json
                                                                            :form-params {:host ""
                                                                                          :scheme ""}})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/targets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"host\": \"\",\n  \"scheme\": \"\"\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}}/api/services/:serviceId/targets"),
    Content = new StringContent("{\n  \"host\": \"\",\n  \"scheme\": \"\"\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}}/api/services/:serviceId/targets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"host\": \"\",\n  \"scheme\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/targets"

	payload := strings.NewReader("{\n  \"host\": \"\",\n  \"scheme\": \"\"\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/api/services/:serviceId/targets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "host": "",
  "scheme": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/services/:serviceId/targets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"host\": \"\",\n  \"scheme\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/targets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"host\": \"\",\n  \"scheme\": \"\"\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  \"host\": \"\",\n  \"scheme\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/targets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/services/:serviceId/targets")
  .header("content-type", "application/json")
  .body("{\n  \"host\": \"\",\n  \"scheme\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  host: '',
  scheme: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/services/:serviceId/targets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services/:serviceId/targets',
  headers: {'content-type': 'application/json'},
  data: {host: '', scheme: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/targets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"host":"","scheme":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services/:serviceId/targets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "host": "",\n  "scheme": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"host\": \"\",\n  \"scheme\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/targets")
  .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/api/services/:serviceId/targets',
  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({host: '', scheme: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services/:serviceId/targets',
  headers: {'content-type': 'application/json'},
  body: {host: '', scheme: ''},
  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}}/api/services/:serviceId/targets');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  host: '',
  scheme: ''
});

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}}/api/services/:serviceId/targets',
  headers: {'content-type': 'application/json'},
  data: {host: '', scheme: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/targets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"host":"","scheme":""}'
};

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 = @{ @"host": @"",
                              @"scheme": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId/targets"]
                                                       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}}/api/services/:serviceId/targets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"host\": \"\",\n  \"scheme\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/targets",
  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([
    'host' => '',
    'scheme' => ''
  ]),
  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}}/api/services/:serviceId/targets', [
  'body' => '{
  "host": "",
  "scheme": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/targets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'host' => '',
  'scheme' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'host' => '',
  'scheme' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId/targets');
$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}}/api/services/:serviceId/targets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "host": "",
  "scheme": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/targets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "host": "",
  "scheme": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"host\": \"\",\n  \"scheme\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/services/:serviceId/targets", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/targets"

payload = {
    "host": "",
    "scheme": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/targets"

payload <- "{\n  \"host\": \"\",\n  \"scheme\": \"\"\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}}/api/services/:serviceId/targets")

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  \"host\": \"\",\n  \"scheme\": \"\"\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/api/services/:serviceId/targets') do |req|
  req.body = "{\n  \"host\": \"\",\n  \"scheme\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/targets";

    let payload = json!({
        "host": "",
        "scheme": ""
    });

    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}}/api/services/:serviceId/targets \
  --header 'content-type: application/json' \
  --data '{
  "host": "",
  "scheme": ""
}'

echo '{
  "host": "",
  "scheme": ""
}' |  \
  http POST {{baseUrl}}/api/services/:serviceId/targets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "host": "",\n  "scheme": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/targets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "host": "",
  "scheme": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/targets")! 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

[
  {
    "host": "www.google.com",
    "scheme": "a string value"
  }
]

POST Create a new service descriptor

{{baseUrl}}/api/services

BODY json

{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services");

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  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/services" {:content-type :json
                                                         :form-params {:Canary {:enabled false
                                                                                :root ""
                                                                                :targets [{:host ""
                                                                                           :scheme ""}]
                                                                                :traffic 0}
                                                                       :additionalHeaders {}
                                                                       :api {:exposeApi false
                                                                             :openApiDescriptorUrl ""}
                                                                       :authConfigRef ""
                                                                       :buildMode false
                                                                       :chaosConfig {:badResponsesFaultConfig {:ratio ""
                                                                                                               :responses [{:body ""
                                                                                                                            :headers {}
                                                                                                                            :status 0}]}
                                                                                     :enabled false
                                                                                     :largeRequestFaultConfig {:additionalRequestSize 0
                                                                                                               :ratio ""}
                                                                                     :largeResponseFaultConfig {:additionalRequestSize 0
                                                                                                                :ratio ""}
                                                                                     :latencyInjectionFaultConfig {:from 0
                                                                                                                   :ratio ""
                                                                                                                   :to 0}}
                                                                       :clientConfig {:backoffFactor 0
                                                                                      :callTimeout 0
                                                                                      :globalTimeout 0
                                                                                      :maxErrors 0
                                                                                      :retries 0
                                                                                      :retryInitialDelay 0
                                                                                      :sampleInterval 0
                                                                                      :useCircuitBreaker false}
                                                                       :clientValidatorRef ""
                                                                       :cors {:allowCredentials false
                                                                              :allowHeaders []
                                                                              :allowMethods []
                                                                              :allowOrigin ""
                                                                              :enabled false
                                                                              :excludedPatterns []
                                                                              :exposeHeaders []
                                                                              :maxAge 0}
                                                                       :domain ""
                                                                       :enabled false
                                                                       :enforceSecureCommunication false
                                                                       :env ""
                                                                       :forceHttps false
                                                                       :groups []
                                                                       :gzip {:blackList []
                                                                              :bufferSize 0
                                                                              :chunkedThreshold 0
                                                                              :compressionLevel 0
                                                                              :enabled false
                                                                              :excludedPatterns []
                                                                              :whiteList []}
                                                                       :headersVerification {}
                                                                       :healthCheck {:enabled false
                                                                                     :url ""}
                                                                       :id ""
                                                                       :ipFiltering {:blacklist []
                                                                                     :whitelist []}
                                                                       :jwtVerifier ""
                                                                       :localHost ""
                                                                       :localScheme ""
                                                                       :maintenanceMode false
                                                                       :matchingHeaders {}
                                                                       :matchingRoot ""
                                                                       :metadata {}
                                                                       :name ""
                                                                       :overrideHost false
                                                                       :privateApp false
                                                                       :privatePatterns []
                                                                       :publicPatterns []
                                                                       :redirectToLocal false
                                                                       :redirection {:code 0
                                                                                     :enabled false
                                                                                     :to ""}
                                                                       :root ""
                                                                       :secComExcludedPatterns []
                                                                       :secComSettings ""
                                                                       :sendOtoroshiHeadersBack false
                                                                       :statsdConfig {:datadog false
                                                                                      :host ""
                                                                                      :port 0}
                                                                       :subdomain ""
                                                                       :targets [{}]
                                                                       :transformerRef ""
                                                                       :userFacing false
                                                                       :xForwardedHeaders false}})

require "http/client"

url = "{{baseUrl}}/api/services"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/services"),
    Content = new StringContent("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services"

	payload := strings.NewReader("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/services HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2405

{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/services")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/services")
  .header("content-type", "application/json")
  .body("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
  .asString();

const data = JSON.stringify({
  Canary: {
    enabled: false,
    root: '',
    targets: [
      {
        host: '',
        scheme: ''
      }
    ],
    traffic: 0
  },
  additionalHeaders: {},
  api: {
    exposeApi: false,
    openApiDescriptorUrl: ''
  },
  authConfigRef: '',
  buildMode: false,
  chaosConfig: {
    badResponsesFaultConfig: {
      ratio: '',
      responses: [
        {
          body: '',
          headers: {},
          status: 0
        }
      ]
    },
    enabled: false,
    largeRequestFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    largeResponseFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    latencyInjectionFaultConfig: {
      from: 0,
      ratio: '',
      to: 0
    }
  },
  clientConfig: {
    backoffFactor: 0,
    callTimeout: 0,
    globalTimeout: 0,
    maxErrors: 0,
    retries: 0,
    retryInitialDelay: 0,
    sampleInterval: 0,
    useCircuitBreaker: false
  },
  clientValidatorRef: '',
  cors: {
    allowCredentials: false,
    allowHeaders: [],
    allowMethods: [],
    allowOrigin: '',
    enabled: false,
    excludedPatterns: [],
    exposeHeaders: [],
    maxAge: 0
  },
  domain: '',
  enabled: false,
  enforceSecureCommunication: false,
  env: '',
  forceHttps: false,
  groups: [],
  gzip: {
    blackList: [],
    bufferSize: 0,
    chunkedThreshold: 0,
    compressionLevel: 0,
    enabled: false,
    excludedPatterns: [],
    whiteList: []
  },
  headersVerification: {},
  healthCheck: {
    enabled: false,
    url: ''
  },
  id: '',
  ipFiltering: {
    blacklist: [],
    whitelist: []
  },
  jwtVerifier: '',
  localHost: '',
  localScheme: '',
  maintenanceMode: false,
  matchingHeaders: {},
  matchingRoot: '',
  metadata: {},
  name: '',
  overrideHost: false,
  privateApp: false,
  privatePatterns: [],
  publicPatterns: [],
  redirectToLocal: false,
  redirection: {
    code: 0,
    enabled: false,
    to: ''
  },
  root: '',
  secComExcludedPatterns: [],
  secComSettings: '',
  sendOtoroshiHeadersBack: false,
  statsdConfig: {
    datadog: false,
    host: '',
    port: 0
  },
  subdomain: '',
  targets: [
    {}
  ],
  transformerRef: '',
  userFacing: false,
  xForwardedHeaders: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/services');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services',
  headers: {'content-type': 'application/json'},
  data: {
    Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
    additionalHeaders: {},
    api: {exposeApi: false, openApiDescriptorUrl: ''},
    authConfigRef: '',
    buildMode: false,
    chaosConfig: {
      badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
      enabled: false,
      largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
      largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
      latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
    },
    clientConfig: {
      backoffFactor: 0,
      callTimeout: 0,
      globalTimeout: 0,
      maxErrors: 0,
      retries: 0,
      retryInitialDelay: 0,
      sampleInterval: 0,
      useCircuitBreaker: false
    },
    clientValidatorRef: '',
    cors: {
      allowCredentials: false,
      allowHeaders: [],
      allowMethods: [],
      allowOrigin: '',
      enabled: false,
      excludedPatterns: [],
      exposeHeaders: [],
      maxAge: 0
    },
    domain: '',
    enabled: false,
    enforceSecureCommunication: false,
    env: '',
    forceHttps: false,
    groups: [],
    gzip: {
      blackList: [],
      bufferSize: 0,
      chunkedThreshold: 0,
      compressionLevel: 0,
      enabled: false,
      excludedPatterns: [],
      whiteList: []
    },
    headersVerification: {},
    healthCheck: {enabled: false, url: ''},
    id: '',
    ipFiltering: {blacklist: [], whitelist: []},
    jwtVerifier: '',
    localHost: '',
    localScheme: '',
    maintenanceMode: false,
    matchingHeaders: {},
    matchingRoot: '',
    metadata: {},
    name: '',
    overrideHost: false,
    privateApp: false,
    privatePatterns: [],
    publicPatterns: [],
    redirectToLocal: false,
    redirection: {code: 0, enabled: false, to: ''},
    root: '',
    secComExcludedPatterns: [],
    secComSettings: '',
    sendOtoroshiHeadersBack: false,
    statsdConfig: {datadog: false, host: '', port: 0},
    subdomain: '',
    targets: [{}],
    transformerRef: '',
    userFacing: false,
    xForwardedHeaders: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{"blacklist":[],"whitelist":[]},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Canary": {\n    "enabled": false,\n    "root": "",\n    "targets": [\n      {\n        "host": "",\n        "scheme": ""\n      }\n    ],\n    "traffic": 0\n  },\n  "additionalHeaders": {},\n  "api": {\n    "exposeApi": false,\n    "openApiDescriptorUrl": ""\n  },\n  "authConfigRef": "",\n  "buildMode": false,\n  "chaosConfig": {\n    "badResponsesFaultConfig": {\n      "ratio": "",\n      "responses": [\n        {\n          "body": "",\n          "headers": {},\n          "status": 0\n        }\n      ]\n    },\n    "enabled": false,\n    "largeRequestFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "largeResponseFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "latencyInjectionFaultConfig": {\n      "from": 0,\n      "ratio": "",\n      "to": 0\n    }\n  },\n  "clientConfig": {\n    "backoffFactor": 0,\n    "callTimeout": 0,\n    "globalTimeout": 0,\n    "maxErrors": 0,\n    "retries": 0,\n    "retryInitialDelay": 0,\n    "sampleInterval": 0,\n    "useCircuitBreaker": false\n  },\n  "clientValidatorRef": "",\n  "cors": {\n    "allowCredentials": false,\n    "allowHeaders": [],\n    "allowMethods": [],\n    "allowOrigin": "",\n    "enabled": false,\n    "excludedPatterns": [],\n    "exposeHeaders": [],\n    "maxAge": 0\n  },\n  "domain": "",\n  "enabled": false,\n  "enforceSecureCommunication": false,\n  "env": "",\n  "forceHttps": false,\n  "groups": [],\n  "gzip": {\n    "blackList": [],\n    "bufferSize": 0,\n    "chunkedThreshold": 0,\n    "compressionLevel": 0,\n    "enabled": false,\n    "excludedPatterns": [],\n    "whiteList": []\n  },\n  "headersVerification": {},\n  "healthCheck": {\n    "enabled": false,\n    "url": ""\n  },\n  "id": "",\n  "ipFiltering": {\n    "blacklist": [],\n    "whitelist": []\n  },\n  "jwtVerifier": "",\n  "localHost": "",\n  "localScheme": "",\n  "maintenanceMode": false,\n  "matchingHeaders": {},\n  "matchingRoot": "",\n  "metadata": {},\n  "name": "",\n  "overrideHost": false,\n  "privateApp": false,\n  "privatePatterns": [],\n  "publicPatterns": [],\n  "redirectToLocal": false,\n  "redirection": {\n    "code": 0,\n    "enabled": false,\n    "to": ""\n  },\n  "root": "",\n  "secComExcludedPatterns": [],\n  "secComSettings": "",\n  "sendOtoroshiHeadersBack": false,\n  "statsdConfig": {\n    "datadog": false,\n    "host": "",\n    "port": 0\n  },\n  "subdomain": "",\n  "targets": [\n    {}\n  ],\n  "transformerRef": "",\n  "userFacing": false,\n  "xForwardedHeaders": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services")
  .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/api/services',
  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({
  Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
  additionalHeaders: {},
  api: {exposeApi: false, openApiDescriptorUrl: ''},
  authConfigRef: '',
  buildMode: false,
  chaosConfig: {
    badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
    enabled: false,
    largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
    largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
    latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
  },
  clientConfig: {
    backoffFactor: 0,
    callTimeout: 0,
    globalTimeout: 0,
    maxErrors: 0,
    retries: 0,
    retryInitialDelay: 0,
    sampleInterval: 0,
    useCircuitBreaker: false
  },
  clientValidatorRef: '',
  cors: {
    allowCredentials: false,
    allowHeaders: [],
    allowMethods: [],
    allowOrigin: '',
    enabled: false,
    excludedPatterns: [],
    exposeHeaders: [],
    maxAge: 0
  },
  domain: '',
  enabled: false,
  enforceSecureCommunication: false,
  env: '',
  forceHttps: false,
  groups: [],
  gzip: {
    blackList: [],
    bufferSize: 0,
    chunkedThreshold: 0,
    compressionLevel: 0,
    enabled: false,
    excludedPatterns: [],
    whiteList: []
  },
  headersVerification: {},
  healthCheck: {enabled: false, url: ''},
  id: '',
  ipFiltering: {blacklist: [], whitelist: []},
  jwtVerifier: '',
  localHost: '',
  localScheme: '',
  maintenanceMode: false,
  matchingHeaders: {},
  matchingRoot: '',
  metadata: {},
  name: '',
  overrideHost: false,
  privateApp: false,
  privatePatterns: [],
  publicPatterns: [],
  redirectToLocal: false,
  redirection: {code: 0, enabled: false, to: ''},
  root: '',
  secComExcludedPatterns: [],
  secComSettings: '',
  sendOtoroshiHeadersBack: false,
  statsdConfig: {datadog: false, host: '', port: 0},
  subdomain: '',
  targets: [{}],
  transformerRef: '',
  userFacing: false,
  xForwardedHeaders: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services',
  headers: {'content-type': 'application/json'},
  body: {
    Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
    additionalHeaders: {},
    api: {exposeApi: false, openApiDescriptorUrl: ''},
    authConfigRef: '',
    buildMode: false,
    chaosConfig: {
      badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
      enabled: false,
      largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
      largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
      latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
    },
    clientConfig: {
      backoffFactor: 0,
      callTimeout: 0,
      globalTimeout: 0,
      maxErrors: 0,
      retries: 0,
      retryInitialDelay: 0,
      sampleInterval: 0,
      useCircuitBreaker: false
    },
    clientValidatorRef: '',
    cors: {
      allowCredentials: false,
      allowHeaders: [],
      allowMethods: [],
      allowOrigin: '',
      enabled: false,
      excludedPatterns: [],
      exposeHeaders: [],
      maxAge: 0
    },
    domain: '',
    enabled: false,
    enforceSecureCommunication: false,
    env: '',
    forceHttps: false,
    groups: [],
    gzip: {
      blackList: [],
      bufferSize: 0,
      chunkedThreshold: 0,
      compressionLevel: 0,
      enabled: false,
      excludedPatterns: [],
      whiteList: []
    },
    headersVerification: {},
    healthCheck: {enabled: false, url: ''},
    id: '',
    ipFiltering: {blacklist: [], whitelist: []},
    jwtVerifier: '',
    localHost: '',
    localScheme: '',
    maintenanceMode: false,
    matchingHeaders: {},
    matchingRoot: '',
    metadata: {},
    name: '',
    overrideHost: false,
    privateApp: false,
    privatePatterns: [],
    publicPatterns: [],
    redirectToLocal: false,
    redirection: {code: 0, enabled: false, to: ''},
    root: '',
    secComExcludedPatterns: [],
    secComSettings: '',
    sendOtoroshiHeadersBack: false,
    statsdConfig: {datadog: false, host: '', port: 0},
    subdomain: '',
    targets: [{}],
    transformerRef: '',
    userFacing: false,
    xForwardedHeaders: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/services');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Canary: {
    enabled: false,
    root: '',
    targets: [
      {
        host: '',
        scheme: ''
      }
    ],
    traffic: 0
  },
  additionalHeaders: {},
  api: {
    exposeApi: false,
    openApiDescriptorUrl: ''
  },
  authConfigRef: '',
  buildMode: false,
  chaosConfig: {
    badResponsesFaultConfig: {
      ratio: '',
      responses: [
        {
          body: '',
          headers: {},
          status: 0
        }
      ]
    },
    enabled: false,
    largeRequestFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    largeResponseFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    latencyInjectionFaultConfig: {
      from: 0,
      ratio: '',
      to: 0
    }
  },
  clientConfig: {
    backoffFactor: 0,
    callTimeout: 0,
    globalTimeout: 0,
    maxErrors: 0,
    retries: 0,
    retryInitialDelay: 0,
    sampleInterval: 0,
    useCircuitBreaker: false
  },
  clientValidatorRef: '',
  cors: {
    allowCredentials: false,
    allowHeaders: [],
    allowMethods: [],
    allowOrigin: '',
    enabled: false,
    excludedPatterns: [],
    exposeHeaders: [],
    maxAge: 0
  },
  domain: '',
  enabled: false,
  enforceSecureCommunication: false,
  env: '',
  forceHttps: false,
  groups: [],
  gzip: {
    blackList: [],
    bufferSize: 0,
    chunkedThreshold: 0,
    compressionLevel: 0,
    enabled: false,
    excludedPatterns: [],
    whiteList: []
  },
  headersVerification: {},
  healthCheck: {
    enabled: false,
    url: ''
  },
  id: '',
  ipFiltering: {
    blacklist: [],
    whitelist: []
  },
  jwtVerifier: '',
  localHost: '',
  localScheme: '',
  maintenanceMode: false,
  matchingHeaders: {},
  matchingRoot: '',
  metadata: {},
  name: '',
  overrideHost: false,
  privateApp: false,
  privatePatterns: [],
  publicPatterns: [],
  redirectToLocal: false,
  redirection: {
    code: 0,
    enabled: false,
    to: ''
  },
  root: '',
  secComExcludedPatterns: [],
  secComSettings: '',
  sendOtoroshiHeadersBack: false,
  statsdConfig: {
    datadog: false,
    host: '',
    port: 0
  },
  subdomain: '',
  targets: [
    {}
  ],
  transformerRef: '',
  userFacing: false,
  xForwardedHeaders: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services',
  headers: {'content-type': 'application/json'},
  data: {
    Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
    additionalHeaders: {},
    api: {exposeApi: false, openApiDescriptorUrl: ''},
    authConfigRef: '',
    buildMode: false,
    chaosConfig: {
      badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
      enabled: false,
      largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
      largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
      latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
    },
    clientConfig: {
      backoffFactor: 0,
      callTimeout: 0,
      globalTimeout: 0,
      maxErrors: 0,
      retries: 0,
      retryInitialDelay: 0,
      sampleInterval: 0,
      useCircuitBreaker: false
    },
    clientValidatorRef: '',
    cors: {
      allowCredentials: false,
      allowHeaders: [],
      allowMethods: [],
      allowOrigin: '',
      enabled: false,
      excludedPatterns: [],
      exposeHeaders: [],
      maxAge: 0
    },
    domain: '',
    enabled: false,
    enforceSecureCommunication: false,
    env: '',
    forceHttps: false,
    groups: [],
    gzip: {
      blackList: [],
      bufferSize: 0,
      chunkedThreshold: 0,
      compressionLevel: 0,
      enabled: false,
      excludedPatterns: [],
      whiteList: []
    },
    headersVerification: {},
    healthCheck: {enabled: false, url: ''},
    id: '',
    ipFiltering: {blacklist: [], whitelist: []},
    jwtVerifier: '',
    localHost: '',
    localScheme: '',
    maintenanceMode: false,
    matchingHeaders: {},
    matchingRoot: '',
    metadata: {},
    name: '',
    overrideHost: false,
    privateApp: false,
    privatePatterns: [],
    publicPatterns: [],
    redirectToLocal: false,
    redirection: {code: 0, enabled: false, to: ''},
    root: '',
    secComExcludedPatterns: [],
    secComSettings: '',
    sendOtoroshiHeadersBack: false,
    statsdConfig: {datadog: false, host: '', port: 0},
    subdomain: '',
    targets: [{}],
    transformerRef: '',
    userFacing: false,
    xForwardedHeaders: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{"blacklist":[],"whitelist":[]},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Canary": @{ @"enabled": @NO, @"root": @"", @"targets": @[ @{ @"host": @"", @"scheme": @"" } ], @"traffic": @0 },
                              @"additionalHeaders": @{  },
                              @"api": @{ @"exposeApi": @NO, @"openApiDescriptorUrl": @"" },
                              @"authConfigRef": @"",
                              @"buildMode": @NO,
                              @"chaosConfig": @{ @"badResponsesFaultConfig": @{ @"ratio": @"", @"responses": @[ @{ @"body": @"", @"headers": @{  }, @"status": @0 } ] }, @"enabled": @NO, @"largeRequestFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"largeResponseFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"latencyInjectionFaultConfig": @{ @"from": @0, @"ratio": @"", @"to": @0 } },
                              @"clientConfig": @{ @"backoffFactor": @0, @"callTimeout": @0, @"globalTimeout": @0, @"maxErrors": @0, @"retries": @0, @"retryInitialDelay": @0, @"sampleInterval": @0, @"useCircuitBreaker": @NO },
                              @"clientValidatorRef": @"",
                              @"cors": @{ @"allowCredentials": @NO, @"allowHeaders": @[  ], @"allowMethods": @[  ], @"allowOrigin": @"", @"enabled": @NO, @"excludedPatterns": @[  ], @"exposeHeaders": @[  ], @"maxAge": @0 },
                              @"domain": @"",
                              @"enabled": @NO,
                              @"enforceSecureCommunication": @NO,
                              @"env": @"",
                              @"forceHttps": @NO,
                              @"groups": @[  ],
                              @"gzip": @{ @"blackList": @[  ], @"bufferSize": @0, @"chunkedThreshold": @0, @"compressionLevel": @0, @"enabled": @NO, @"excludedPatterns": @[  ], @"whiteList": @[  ] },
                              @"headersVerification": @{  },
                              @"healthCheck": @{ @"enabled": @NO, @"url": @"" },
                              @"id": @"",
                              @"ipFiltering": @{ @"blacklist": @[  ], @"whitelist": @[  ] },
                              @"jwtVerifier": @"",
                              @"localHost": @"",
                              @"localScheme": @"",
                              @"maintenanceMode": @NO,
                              @"matchingHeaders": @{  },
                              @"matchingRoot": @"",
                              @"metadata": @{  },
                              @"name": @"",
                              @"overrideHost": @NO,
                              @"privateApp": @NO,
                              @"privatePatterns": @[  ],
                              @"publicPatterns": @[  ],
                              @"redirectToLocal": @NO,
                              @"redirection": @{ @"code": @0, @"enabled": @NO, @"to": @"" },
                              @"root": @"",
                              @"secComExcludedPatterns": @[  ],
                              @"secComSettings": @"",
                              @"sendOtoroshiHeadersBack": @NO,
                              @"statsdConfig": @{ @"datadog": @NO, @"host": @"", @"port": @0 },
                              @"subdomain": @"",
                              @"targets": @[ @{  } ],
                              @"transformerRef": @"",
                              @"userFacing": @NO,
                              @"xForwardedHeaders": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services"]
                                                       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}}/api/services" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services",
  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([
    'Canary' => [
        'enabled' => null,
        'root' => '',
        'targets' => [
                [
                                'host' => '',
                                'scheme' => ''
                ]
        ],
        'traffic' => 0
    ],
    'additionalHeaders' => [
        
    ],
    'api' => [
        'exposeApi' => null,
        'openApiDescriptorUrl' => ''
    ],
    'authConfigRef' => '',
    'buildMode' => null,
    'chaosConfig' => [
        'badResponsesFaultConfig' => [
                'ratio' => '',
                'responses' => [
                                [
                                                                'body' => '',
                                                                'headers' => [
                                                                                                                                
                                                                ],
                                                                'status' => 0
                                ]
                ]
        ],
        'enabled' => null,
        'largeRequestFaultConfig' => [
                'additionalRequestSize' => 0,
                'ratio' => ''
        ],
        'largeResponseFaultConfig' => [
                'additionalRequestSize' => 0,
                'ratio' => ''
        ],
        'latencyInjectionFaultConfig' => [
                'from' => 0,
                'ratio' => '',
                'to' => 0
        ]
    ],
    'clientConfig' => [
        'backoffFactor' => 0,
        'callTimeout' => 0,
        'globalTimeout' => 0,
        'maxErrors' => 0,
        'retries' => 0,
        'retryInitialDelay' => 0,
        'sampleInterval' => 0,
        'useCircuitBreaker' => null
    ],
    'clientValidatorRef' => '',
    'cors' => [
        'allowCredentials' => null,
        'allowHeaders' => [
                
        ],
        'allowMethods' => [
                
        ],
        'allowOrigin' => '',
        'enabled' => null,
        'excludedPatterns' => [
                
        ],
        'exposeHeaders' => [
                
        ],
        'maxAge' => 0
    ],
    'domain' => '',
    'enabled' => null,
    'enforceSecureCommunication' => null,
    'env' => '',
    'forceHttps' => null,
    'groups' => [
        
    ],
    'gzip' => [
        'blackList' => [
                
        ],
        'bufferSize' => 0,
        'chunkedThreshold' => 0,
        'compressionLevel' => 0,
        'enabled' => null,
        'excludedPatterns' => [
                
        ],
        'whiteList' => [
                
        ]
    ],
    'headersVerification' => [
        
    ],
    'healthCheck' => [
        'enabled' => null,
        'url' => ''
    ],
    'id' => '',
    'ipFiltering' => [
        'blacklist' => [
                
        ],
        'whitelist' => [
                
        ]
    ],
    'jwtVerifier' => '',
    'localHost' => '',
    'localScheme' => '',
    'maintenanceMode' => null,
    'matchingHeaders' => [
        
    ],
    'matchingRoot' => '',
    'metadata' => [
        
    ],
    'name' => '',
    'overrideHost' => null,
    'privateApp' => null,
    'privatePatterns' => [
        
    ],
    'publicPatterns' => [
        
    ],
    'redirectToLocal' => null,
    'redirection' => [
        'code' => 0,
        'enabled' => null,
        'to' => ''
    ],
    'root' => '',
    'secComExcludedPatterns' => [
        
    ],
    'secComSettings' => '',
    'sendOtoroshiHeadersBack' => null,
    'statsdConfig' => [
        'datadog' => null,
        'host' => '',
        'port' => 0
    ],
    'subdomain' => '',
    'targets' => [
        [
                
        ]
    ],
    'transformerRef' => '',
    'userFacing' => null,
    'xForwardedHeaders' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/services', [
  'body' => '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Canary' => [
    'enabled' => null,
    'root' => '',
    'targets' => [
        [
                'host' => '',
                'scheme' => ''
        ]
    ],
    'traffic' => 0
  ],
  'additionalHeaders' => [
    
  ],
  'api' => [
    'exposeApi' => null,
    'openApiDescriptorUrl' => ''
  ],
  'authConfigRef' => '',
  'buildMode' => null,
  'chaosConfig' => [
    'badResponsesFaultConfig' => [
        'ratio' => '',
        'responses' => [
                [
                                'body' => '',
                                'headers' => [
                                                                
                                ],
                                'status' => 0
                ]
        ]
    ],
    'enabled' => null,
    'largeRequestFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'largeResponseFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'latencyInjectionFaultConfig' => [
        'from' => 0,
        'ratio' => '',
        'to' => 0
    ]
  ],
  'clientConfig' => [
    'backoffFactor' => 0,
    'callTimeout' => 0,
    'globalTimeout' => 0,
    'maxErrors' => 0,
    'retries' => 0,
    'retryInitialDelay' => 0,
    'sampleInterval' => 0,
    'useCircuitBreaker' => null
  ],
  'clientValidatorRef' => '',
  'cors' => [
    'allowCredentials' => null,
    'allowHeaders' => [
        
    ],
    'allowMethods' => [
        
    ],
    'allowOrigin' => '',
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'exposeHeaders' => [
        
    ],
    'maxAge' => 0
  ],
  'domain' => '',
  'enabled' => null,
  'enforceSecureCommunication' => null,
  'env' => '',
  'forceHttps' => null,
  'groups' => [
    
  ],
  'gzip' => [
    'blackList' => [
        
    ],
    'bufferSize' => 0,
    'chunkedThreshold' => 0,
    'compressionLevel' => 0,
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'whiteList' => [
        
    ]
  ],
  'headersVerification' => [
    
  ],
  'healthCheck' => [
    'enabled' => null,
    'url' => ''
  ],
  'id' => '',
  'ipFiltering' => [
    'blacklist' => [
        
    ],
    'whitelist' => [
        
    ]
  ],
  'jwtVerifier' => '',
  'localHost' => '',
  'localScheme' => '',
  'maintenanceMode' => null,
  'matchingHeaders' => [
    
  ],
  'matchingRoot' => '',
  'metadata' => [
    
  ],
  'name' => '',
  'overrideHost' => null,
  'privateApp' => null,
  'privatePatterns' => [
    
  ],
  'publicPatterns' => [
    
  ],
  'redirectToLocal' => null,
  'redirection' => [
    'code' => 0,
    'enabled' => null,
    'to' => ''
  ],
  'root' => '',
  'secComExcludedPatterns' => [
    
  ],
  'secComSettings' => '',
  'sendOtoroshiHeadersBack' => null,
  'statsdConfig' => [
    'datadog' => null,
    'host' => '',
    'port' => 0
  ],
  'subdomain' => '',
  'targets' => [
    [
        
    ]
  ],
  'transformerRef' => '',
  'userFacing' => null,
  'xForwardedHeaders' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Canary' => [
    'enabled' => null,
    'root' => '',
    'targets' => [
        [
                'host' => '',
                'scheme' => ''
        ]
    ],
    'traffic' => 0
  ],
  'additionalHeaders' => [
    
  ],
  'api' => [
    'exposeApi' => null,
    'openApiDescriptorUrl' => ''
  ],
  'authConfigRef' => '',
  'buildMode' => null,
  'chaosConfig' => [
    'badResponsesFaultConfig' => [
        'ratio' => '',
        'responses' => [
                [
                                'body' => '',
                                'headers' => [
                                                                
                                ],
                                'status' => 0
                ]
        ]
    ],
    'enabled' => null,
    'largeRequestFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'largeResponseFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'latencyInjectionFaultConfig' => [
        'from' => 0,
        'ratio' => '',
        'to' => 0
    ]
  ],
  'clientConfig' => [
    'backoffFactor' => 0,
    'callTimeout' => 0,
    'globalTimeout' => 0,
    'maxErrors' => 0,
    'retries' => 0,
    'retryInitialDelay' => 0,
    'sampleInterval' => 0,
    'useCircuitBreaker' => null
  ],
  'clientValidatorRef' => '',
  'cors' => [
    'allowCredentials' => null,
    'allowHeaders' => [
        
    ],
    'allowMethods' => [
        
    ],
    'allowOrigin' => '',
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'exposeHeaders' => [
        
    ],
    'maxAge' => 0
  ],
  'domain' => '',
  'enabled' => null,
  'enforceSecureCommunication' => null,
  'env' => '',
  'forceHttps' => null,
  'groups' => [
    
  ],
  'gzip' => [
    'blackList' => [
        
    ],
    'bufferSize' => 0,
    'chunkedThreshold' => 0,
    'compressionLevel' => 0,
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'whiteList' => [
        
    ]
  ],
  'headersVerification' => [
    
  ],
  'healthCheck' => [
    'enabled' => null,
    'url' => ''
  ],
  'id' => '',
  'ipFiltering' => [
    'blacklist' => [
        
    ],
    'whitelist' => [
        
    ]
  ],
  'jwtVerifier' => '',
  'localHost' => '',
  'localScheme' => '',
  'maintenanceMode' => null,
  'matchingHeaders' => [
    
  ],
  'matchingRoot' => '',
  'metadata' => [
    
  ],
  'name' => '',
  'overrideHost' => null,
  'privateApp' => null,
  'privatePatterns' => [
    
  ],
  'publicPatterns' => [
    
  ],
  'redirectToLocal' => null,
  'redirection' => [
    'code' => 0,
    'enabled' => null,
    'to' => ''
  ],
  'root' => '',
  'secComExcludedPatterns' => [
    
  ],
  'secComSettings' => '',
  'sendOtoroshiHeadersBack' => null,
  'statsdConfig' => [
    'datadog' => null,
    'host' => '',
    'port' => 0
  ],
  'subdomain' => '',
  'targets' => [
    [
        
    ]
  ],
  'transformerRef' => '',
  'userFacing' => null,
  'xForwardedHeaders' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/services');
$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}}/api/services' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/services", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services"

payload = {
    "Canary": {
        "enabled": False,
        "root": "",
        "targets": [
            {
                "host": "",
                "scheme": ""
            }
        ],
        "traffic": 0
    },
    "additionalHeaders": {},
    "api": {
        "exposeApi": False,
        "openApiDescriptorUrl": ""
    },
    "authConfigRef": "",
    "buildMode": False,
    "chaosConfig": {
        "badResponsesFaultConfig": {
            "ratio": "",
            "responses": [
                {
                    "body": "",
                    "headers": {},
                    "status": 0
                }
            ]
        },
        "enabled": False,
        "largeRequestFaultConfig": {
            "additionalRequestSize": 0,
            "ratio": ""
        },
        "largeResponseFaultConfig": {
            "additionalRequestSize": 0,
            "ratio": ""
        },
        "latencyInjectionFaultConfig": {
            "from": 0,
            "ratio": "",
            "to": 0
        }
    },
    "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": False
    },
    "clientValidatorRef": "",
    "cors": {
        "allowCredentials": False,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": False,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
    },
    "domain": "",
    "enabled": False,
    "enforceSecureCommunication": False,
    "env": "",
    "forceHttps": False,
    "groups": [],
    "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": False,
        "excludedPatterns": [],
        "whiteList": []
    },
    "headersVerification": {},
    "healthCheck": {
        "enabled": False,
        "url": ""
    },
    "id": "",
    "ipFiltering": {
        "blacklist": [],
        "whitelist": []
    },
    "jwtVerifier": "",
    "localHost": "",
    "localScheme": "",
    "maintenanceMode": False,
    "matchingHeaders": {},
    "matchingRoot": "",
    "metadata": {},
    "name": "",
    "overrideHost": False,
    "privateApp": False,
    "privatePatterns": [],
    "publicPatterns": [],
    "redirectToLocal": False,
    "redirection": {
        "code": 0,
        "enabled": False,
        "to": ""
    },
    "root": "",
    "secComExcludedPatterns": [],
    "secComSettings": "",
    "sendOtoroshiHeadersBack": False,
    "statsdConfig": {
        "datadog": False,
        "host": "",
        "port": 0
    },
    "subdomain": "",
    "targets": [{}],
    "transformerRef": "",
    "userFacing": False,
    "xForwardedHeaders": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services"

payload <- "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services")

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  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/services') do |req|
  req.body = "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services";

    let payload = json!({
        "Canary": json!({
            "enabled": false,
            "root": "",
            "targets": (
                json!({
                    "host": "",
                    "scheme": ""
                })
            ),
            "traffic": 0
        }),
        "additionalHeaders": json!({}),
        "api": json!({
            "exposeApi": false,
            "openApiDescriptorUrl": ""
        }),
        "authConfigRef": "",
        "buildMode": false,
        "chaosConfig": json!({
            "badResponsesFaultConfig": json!({
                "ratio": "",
                "responses": (
                    json!({
                        "body": "",
                        "headers": json!({}),
                        "status": 0
                    })
                )
            }),
            "enabled": false,
            "largeRequestFaultConfig": json!({
                "additionalRequestSize": 0,
                "ratio": ""
            }),
            "largeResponseFaultConfig": json!({
                "additionalRequestSize": 0,
                "ratio": ""
            }),
            "latencyInjectionFaultConfig": json!({
                "from": 0,
                "ratio": "",
                "to": 0
            })
        }),
        "clientConfig": json!({
            "backoffFactor": 0,
            "callTimeout": 0,
            "globalTimeout": 0,
            "maxErrors": 0,
            "retries": 0,
            "retryInitialDelay": 0,
            "sampleInterval": 0,
            "useCircuitBreaker": false
        }),
        "clientValidatorRef": "",
        "cors": json!({
            "allowCredentials": false,
            "allowHeaders": (),
            "allowMethods": (),
            "allowOrigin": "",
            "enabled": false,
            "excludedPatterns": (),
            "exposeHeaders": (),
            "maxAge": 0
        }),
        "domain": "",
        "enabled": false,
        "enforceSecureCommunication": false,
        "env": "",
        "forceHttps": false,
        "groups": (),
        "gzip": json!({
            "blackList": (),
            "bufferSize": 0,
            "chunkedThreshold": 0,
            "compressionLevel": 0,
            "enabled": false,
            "excludedPatterns": (),
            "whiteList": ()
        }),
        "headersVerification": json!({}),
        "healthCheck": json!({
            "enabled": false,
            "url": ""
        }),
        "id": "",
        "ipFiltering": json!({
            "blacklist": (),
            "whitelist": ()
        }),
        "jwtVerifier": "",
        "localHost": "",
        "localScheme": "",
        "maintenanceMode": false,
        "matchingHeaders": json!({}),
        "matchingRoot": "",
        "metadata": json!({}),
        "name": "",
        "overrideHost": false,
        "privateApp": false,
        "privatePatterns": (),
        "publicPatterns": (),
        "redirectToLocal": false,
        "redirection": json!({
            "code": 0,
            "enabled": false,
            "to": ""
        }),
        "root": "",
        "secComExcludedPatterns": (),
        "secComSettings": "",
        "sendOtoroshiHeadersBack": false,
        "statsdConfig": json!({
            "datadog": false,
            "host": "",
            "port": 0
        }),
        "subdomain": "",
        "targets": (json!({})),
        "transformerRef": "",
        "userFacing": false,
        "xForwardedHeaders": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/services \
  --header 'content-type: application/json' \
  --data '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}'

echo '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}' |  \
  http POST {{baseUrl}}/api/services \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Canary": {\n    "enabled": false,\n    "root": "",\n    "targets": [\n      {\n        "host": "",\n        "scheme": ""\n      }\n    ],\n    "traffic": 0\n  },\n  "additionalHeaders": {},\n  "api": {\n    "exposeApi": false,\n    "openApiDescriptorUrl": ""\n  },\n  "authConfigRef": "",\n  "buildMode": false,\n  "chaosConfig": {\n    "badResponsesFaultConfig": {\n      "ratio": "",\n      "responses": [\n        {\n          "body": "",\n          "headers": {},\n          "status": 0\n        }\n      ]\n    },\n    "enabled": false,\n    "largeRequestFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "largeResponseFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "latencyInjectionFaultConfig": {\n      "from": 0,\n      "ratio": "",\n      "to": 0\n    }\n  },\n  "clientConfig": {\n    "backoffFactor": 0,\n    "callTimeout": 0,\n    "globalTimeout": 0,\n    "maxErrors": 0,\n    "retries": 0,\n    "retryInitialDelay": 0,\n    "sampleInterval": 0,\n    "useCircuitBreaker": false\n  },\n  "clientValidatorRef": "",\n  "cors": {\n    "allowCredentials": false,\n    "allowHeaders": [],\n    "allowMethods": [],\n    "allowOrigin": "",\n    "enabled": false,\n    "excludedPatterns": [],\n    "exposeHeaders": [],\n    "maxAge": 0\n  },\n  "domain": "",\n  "enabled": false,\n  "enforceSecureCommunication": false,\n  "env": "",\n  "forceHttps": false,\n  "groups": [],\n  "gzip": {\n    "blackList": [],\n    "bufferSize": 0,\n    "chunkedThreshold": 0,\n    "compressionLevel": 0,\n    "enabled": false,\n    "excludedPatterns": [],\n    "whiteList": []\n  },\n  "headersVerification": {},\n  "healthCheck": {\n    "enabled": false,\n    "url": ""\n  },\n  "id": "",\n  "ipFiltering": {\n    "blacklist": [],\n    "whitelist": []\n  },\n  "jwtVerifier": "",\n  "localHost": "",\n  "localScheme": "",\n  "maintenanceMode": false,\n  "matchingHeaders": {},\n  "matchingRoot": "",\n  "metadata": {},\n  "name": "",\n  "overrideHost": false,\n  "privateApp": false,\n  "privatePatterns": [],\n  "publicPatterns": [],\n  "redirectToLocal": false,\n  "redirection": {\n    "code": 0,\n    "enabled": false,\n    "to": ""\n  },\n  "root": "",\n  "secComExcludedPatterns": [],\n  "secComSettings": "",\n  "sendOtoroshiHeadersBack": false,\n  "statsdConfig": {\n    "datadog": false,\n    "host": "",\n    "port": 0\n  },\n  "subdomain": "",\n  "targets": [\n    {}\n  ],\n  "transformerRef": "",\n  "userFacing": false,\n  "xForwardedHeaders": false\n}' \
  --output-document \
  - {{baseUrl}}/api/services

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Canary": [
    "enabled": false,
    "root": "",
    "targets": [
      [
        "host": "",
        "scheme": ""
      ]
    ],
    "traffic": 0
  ],
  "additionalHeaders": [],
  "api": [
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  ],
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": [
    "badResponsesFaultConfig": [
      "ratio": "",
      "responses": [
        [
          "body": "",
          "headers": [],
          "status": 0
        ]
      ]
    ],
    "enabled": false,
    "largeRequestFaultConfig": [
      "additionalRequestSize": 0,
      "ratio": ""
    ],
    "largeResponseFaultConfig": [
      "additionalRequestSize": 0,
      "ratio": ""
    ],
    "latencyInjectionFaultConfig": [
      "from": 0,
      "ratio": "",
      "to": 0
    ]
  ],
  "clientConfig": [
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  ],
  "clientValidatorRef": "",
  "cors": [
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  ],
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": [
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  ],
  "headersVerification": [],
  "healthCheck": [
    "enabled": false,
    "url": ""
  ],
  "id": "",
  "ipFiltering": [
    "blacklist": [],
    "whitelist": []
  ],
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": [],
  "matchingRoot": "",
  "metadata": [],
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": [
    "code": 0,
    "enabled": false,
    "to": ""
  ],
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": [
    "datadog": false,
    "host": "",
    "port": 0
  ],
  "subdomain": "",
  "targets": [[]],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services")! 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

{
  "Canary": {
    "enabled": true,
    "root": "a string value",
    "traffic": 123123
  },
  "additionalHeaders": {
    "key": "value"
  },
  "api": {
    "exposeApi": true,
    "openApiDescriptorUrl": "http://www.google.com"
  },
  "authConfigRef": "a string value",
  "buildMode": true,
  "chaosConfig": {
    "enabled": true
  },
  "clientConfig": {
    "backoffFactor": 123123,
    "callTimeout": 123123,
    "globalTimeout": 123123,
    "maxErrors": 123123,
    "retries": 123123,
    "retryInitialDelay": 123123,
    "sampleInterval": 123123,
    "useCircuitBreaker": true
  },
  "clientValidatorRef": "a string value",
  "cors": {
    "allowCredentials": true,
    "allowOrigin": "a string value",
    "enabled": true,
    "maxAge": 123123
  },
  "domain": "a string value",
  "enabled": true,
  "enforceSecureCommunication": true,
  "env": "a string value",
  "forceHttps": true,
  "groups": [
    "a string value"
  ],
  "gzip": {
    "bufferSize": 123,
    "chunkedThreshold": 123,
    "compressionLevel": 123123,
    "enabled": true
  },
  "headersVerification": {
    "key": "value"
  },
  "healthCheck": {
    "enabled": true,
    "url": "http://www.google.com"
  },
  "id": "110e8400-e29b-11d4-a716-446655440000",
  "localHost": "a string value",
  "localScheme": "a string value",
  "maintenanceMode": true,
  "matchingHeaders": {
    "key": "value"
  },
  "matchingRoot": "a string value",
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "overrideHost": true,
  "privateApp": true,
  "privatePatterns": [
    "a string value"
  ],
  "publicPatterns": [
    "a string value"
  ],
  "redirectToLocal": true,
  "redirection": {
    "code": 123123,
    "enabled": true,
    "to": "a string value"
  },
  "root": "a string value",
  "secComExcludedPatterns": [
    "a string value"
  ],
  "sendOtoroshiHeadersBack": true,
  "statsdConfig": {
    "datadog": true,
    "host": "a string value",
    "port": 123123
  },
  "subdomain": "a string value",
  "transformerRef": "a string value",
  "userFacing": true,
  "xForwardedHeaders": true
}

POST Create a service descriptor error template

{{baseUrl}}/api/services/:serviceId/template

QUERY PARAMS

serviceId

BODY json

{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/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  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/services/:serviceId/template" {:content-type :json
                                                                             :form-params {:messages {}
                                                                                           :serviceId ""
                                                                                           :template40x ""
                                                                                           :template50x ""
                                                                                           :templateBuild ""
                                                                                           :templateMaintenance ""}})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/template"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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}}/api/services/:serviceId/template"),
    Content = new StringContent("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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}}/api/services/:serviceId/template");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/template"

	payload := strings.NewReader("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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/api/services/:serviceId/template HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 133

{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/services/:serviceId/template")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/template"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/template")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/services/:serviceId/template")
  .header("content-type", "application/json")
  .body("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  messages: {},
  serviceId: '',
  template40x: '',
  template50x: '',
  templateBuild: '',
  templateMaintenance: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/services/:serviceId/template');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services/:serviceId/template',
  headers: {'content-type': 'application/json'},
  data: {
    messages: {},
    serviceId: '',
    template40x: '',
    template50x: '',
    templateBuild: '',
    templateMaintenance: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/template';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services/:serviceId/template',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "messages": {},\n  "serviceId": "",\n  "template40x": "",\n  "template50x": "",\n  "templateBuild": "",\n  "templateMaintenance": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/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/api/services/:serviceId/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({
  messages: {},
  serviceId: '',
  template40x: '',
  template50x: '',
  templateBuild: '',
  templateMaintenance: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/services/:serviceId/template',
  headers: {'content-type': 'application/json'},
  body: {
    messages: {},
    serviceId: '',
    template40x: '',
    template50x: '',
    templateBuild: '',
    templateMaintenance: ''
  },
  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}}/api/services/:serviceId/template');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  messages: {},
  serviceId: '',
  template40x: '',
  template50x: '',
  templateBuild: '',
  templateMaintenance: ''
});

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}}/api/services/:serviceId/template',
  headers: {'content-type': 'application/json'},
  data: {
    messages: {},
    serviceId: '',
    template40x: '',
    template50x: '',
    templateBuild: '',
    templateMaintenance: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/template';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}'
};

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 = @{ @"messages": @{  },
                              @"serviceId": @"",
                              @"template40x": @"",
                              @"template50x": @"",
                              @"templateBuild": @"",
                              @"templateMaintenance": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/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([
    'messages' => [
        
    ],
    'serviceId' => '',
    'template40x' => '',
    'template50x' => '',
    'templateBuild' => '',
    'templateMaintenance' => ''
  ]),
  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}}/api/services/:serviceId/template', [
  'body' => '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/template');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'messages' => [
    
  ],
  'serviceId' => '',
  'template40x' => '',
  'template50x' => '',
  'templateBuild' => '',
  'templateMaintenance' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'messages' => [
    
  ],
  'serviceId' => '',
  'template40x' => '',
  'template50x' => '',
  'templateBuild' => '',
  'templateMaintenance' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/template' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/services/:serviceId/template", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/template"

payload = {
    "messages": {},
    "serviceId": "",
    "template40x": "",
    "template50x": "",
    "templateBuild": "",
    "templateMaintenance": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/template"

payload <- "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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}}/api/services/:serviceId/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  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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/api/services/:serviceId/template') do |req|
  req.body = "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/template";

    let payload = json!({
        "messages": json!({}),
        "serviceId": "",
        "template40x": "",
        "template50x": "",
        "templateBuild": "",
        "templateMaintenance": ""
    });

    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}}/api/services/:serviceId/template \
  --header 'content-type: application/json' \
  --data '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}'

echo '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}' |  \
  http POST {{baseUrl}}/api/services/:serviceId/template \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "messages": {},\n  "serviceId": "",\n  "template40x": "",\n  "template50x": "",\n  "templateBuild": "",\n  "templateMaintenance": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/template

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "messages": [],
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "messages": {
    "key": "value"
  },
  "serviceId": "a string value",
  "template40x": "a string value",
  "template50x": "a string value",
  "templateBuild": "a string value",
  "templateMaintenance": "a string value"
}

DELETE Delete a service descriptor error template

{{baseUrl}}/api/services/:serviceId/template

QUERY PARAMS

serviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/template");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/services/:serviceId/template")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/template");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/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/api/services/:serviceId/template HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/services/:serviceId/template")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/services/:serviceId/template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/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/api/services/:serviceId/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}}/api/services/:serviceId/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}}/api/services/:serviceId/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}}/api/services/:serviceId/template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/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}}/api/services/:serviceId/template" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/template');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/services/:serviceId/template');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/template' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/template' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/services/:serviceId/template")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/template"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/template"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/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/api/services/:serviceId/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}}/api/services/:serviceId/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}}/api/services/:serviceId/template

http DELETE {{baseUrl}}/api/services/:serviceId/template

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/template

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

DELETE Delete a service descriptor target

{{baseUrl}}/api/services/:serviceId/targets

QUERY PARAMS

serviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/targets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/services/:serviceId/targets")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/targets"

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}}/api/services/:serviceId/targets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/targets");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/targets"

	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/api/services/:serviceId/targets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/services/:serviceId/targets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/targets"))
    .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}}/api/services/:serviceId/targets")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/services/:serviceId/targets")
  .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}}/api/services/:serviceId/targets');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/services/:serviceId/targets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/targets';
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}}/api/services/:serviceId/targets',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/targets")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId/targets',
  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}}/api/services/:serviceId/targets'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/services/:serviceId/targets');

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}}/api/services/:serviceId/targets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/targets';
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}}/api/services/:serviceId/targets"]
                                                       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}}/api/services/:serviceId/targets" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/targets",
  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}}/api/services/:serviceId/targets');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/targets');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/services/:serviceId/targets');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/targets' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/targets' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/services/:serviceId/targets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/targets"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/targets"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/targets")

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/api/services/:serviceId/targets') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/targets";

    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}}/api/services/:serviceId/targets

http DELETE {{baseUrl}}/api/services/:serviceId/targets

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/targets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/targets")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "host": "www.google.com",
    "scheme": "a string value"
  }
]

DELETE Delete a service descriptor

{{baseUrl}}/api/services/:serviceId

QUERY PARAMS

serviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/services/:serviceId")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId"

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}}/api/services/:serviceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services/:serviceId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId"

	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/api/services/:serviceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/services/:serviceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId"))
    .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}}/api/services/:serviceId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/services/:serviceId")
  .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}}/api/services/:serviceId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/services/:serviceId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId';
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}}/api/services/:serviceId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId',
  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}}/api/services/:serviceId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/services/:serviceId');

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}}/api/services/:serviceId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId';
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}}/api/services/:serviceId"]
                                                       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}}/api/services/:serviceId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId",
  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}}/api/services/:serviceId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/services/:serviceId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/services/:serviceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId")

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/api/services/:serviceId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId";

    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}}/api/services/:serviceId

http DELETE {{baseUrl}}/api/services/:serviceId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get a service descriptor error template

{{baseUrl}}/api/services/:serviceId/template

QUERY PARAMS

serviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/template");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/services/:serviceId/template")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/template");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/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/api/services/:serviceId/template HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/services/:serviceId/template")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/services/:serviceId/template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/template")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId/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}}/api/services/:serviceId/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}}/api/services/:serviceId/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}}/api/services/:serviceId/template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/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}}/api/services/:serviceId/template" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/template');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/services/:serviceId/template');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/template' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/template' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/services/:serviceId/template")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/template"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/template"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/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/api/services/:serviceId/template') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/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}}/api/services/:serviceId/template

http GET {{baseUrl}}/api/services/:serviceId/template

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/template

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/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

{
  "messages": {
    "key": "value"
  },
  "serviceId": "a string value",
  "template40x": "a string value",
  "template50x": "a string value",
  "templateBuild": "a string value",
  "templateMaintenance": "a string value"
}

GET Get a service descriptor targets

{{baseUrl}}/api/services/:serviceId/targets

QUERY PARAMS

serviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/targets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/services/:serviceId/targets")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/targets"

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}}/api/services/:serviceId/targets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services/:serviceId/targets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/targets"

	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/api/services/:serviceId/targets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/services/:serviceId/targets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/targets"))
    .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}}/api/services/:serviceId/targets")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/services/:serviceId/targets")
  .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}}/api/services/:serviceId/targets');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/services/:serviceId/targets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/targets';
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}}/api/services/:serviceId/targets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/targets")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId/targets',
  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}}/api/services/:serviceId/targets'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/services/:serviceId/targets');

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}}/api/services/:serviceId/targets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/targets';
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}}/api/services/:serviceId/targets"]
                                                       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}}/api/services/:serviceId/targets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/targets",
  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}}/api/services/:serviceId/targets');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/targets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/services/:serviceId/targets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId/targets' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/targets' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/services/:serviceId/targets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/targets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/targets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/targets")

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/api/services/:serviceId/targets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/targets";

    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}}/api/services/:serviceId/targets

http GET {{baseUrl}}/api/services/:serviceId/targets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/targets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/targets")! 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

[
  {
    "host": "www.google.com",
    "scheme": "a string value"
  }
]

GET Get a service descriptor

{{baseUrl}}/api/services/:serviceId

QUERY PARAMS

serviceId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/services/:serviceId")

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId"

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}}/api/services/:serviceId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services/:serviceId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId"

	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/api/services/:serviceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/services/:serviceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId"))
    .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}}/api/services/:serviceId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/services/:serviceId")
  .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}}/api/services/:serviceId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/services/:serviceId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId';
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}}/api/services/:serviceId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId',
  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}}/api/services/:serviceId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/services/:serviceId');

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}}/api/services/:serviceId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId';
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}}/api/services/:serviceId"]
                                                       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}}/api/services/:serviceId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId",
  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}}/api/services/:serviceId');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/services/:serviceId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services/:serviceId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/services/:serviceId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId")

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/api/services/:serviceId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId";

    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}}/api/services/:serviceId

http GET {{baseUrl}}/api/services/:serviceId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId")! 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

{
  "Canary": {
    "enabled": true,
    "root": "a string value",
    "traffic": 123123
  },
  "additionalHeaders": {
    "key": "value"
  },
  "api": {
    "exposeApi": true,
    "openApiDescriptorUrl": "http://www.google.com"
  },
  "authConfigRef": "a string value",
  "buildMode": true,
  "chaosConfig": {
    "enabled": true
  },
  "clientConfig": {
    "backoffFactor": 123123,
    "callTimeout": 123123,
    "globalTimeout": 123123,
    "maxErrors": 123123,
    "retries": 123123,
    "retryInitialDelay": 123123,
    "sampleInterval": 123123,
    "useCircuitBreaker": true
  },
  "clientValidatorRef": "a string value",
  "cors": {
    "allowCredentials": true,
    "allowOrigin": "a string value",
    "enabled": true,
    "maxAge": 123123
  },
  "domain": "a string value",
  "enabled": true,
  "enforceSecureCommunication": true,
  "env": "a string value",
  "forceHttps": true,
  "groups": [
    "a string value"
  ],
  "gzip": {
    "bufferSize": 123,
    "chunkedThreshold": 123,
    "compressionLevel": 123123,
    "enabled": true
  },
  "headersVerification": {
    "key": "value"
  },
  "healthCheck": {
    "enabled": true,
    "url": "http://www.google.com"
  },
  "id": "110e8400-e29b-11d4-a716-446655440000",
  "localHost": "a string value",
  "localScheme": "a string value",
  "maintenanceMode": true,
  "matchingHeaders": {
    "key": "value"
  },
  "matchingRoot": "a string value",
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "overrideHost": true,
  "privateApp": true,
  "privatePatterns": [
    "a string value"
  ],
  "publicPatterns": [
    "a string value"
  ],
  "redirectToLocal": true,
  "redirection": {
    "code": 123123,
    "enabled": true,
    "to": "a string value"
  },
  "root": "a string value",
  "secComExcludedPatterns": [
    "a string value"
  ],
  "sendOtoroshiHeadersBack": true,
  "statsdConfig": {
    "datadog": true,
    "host": "a string value",
    "port": 123123
  },
  "subdomain": "a string value",
  "transformerRef": "a string value",
  "userFacing": true,
  "xForwardedHeaders": true
}

GET Get all services descriptor for a group

{{baseUrl}}/api/groups/:serviceGroupId/services

QUERY PARAMS

serviceGroupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/groups/:serviceGroupId/services");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/groups/:serviceGroupId/services")

require "http/client"

url = "{{baseUrl}}/api/groups/:serviceGroupId/services"

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}}/api/groups/:serviceGroupId/services"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/groups/:serviceGroupId/services");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/groups/:serviceGroupId/services"

	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/api/groups/:serviceGroupId/services HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/groups/:serviceGroupId/services")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/groups/:serviceGroupId/services"))
    .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}}/api/groups/:serviceGroupId/services")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/groups/:serviceGroupId/services")
  .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}}/api/groups/:serviceGroupId/services');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/groups/:serviceGroupId/services'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/groups/:serviceGroupId/services';
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}}/api/groups/:serviceGroupId/services',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/groups/:serviceGroupId/services")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/groups/:serviceGroupId/services',
  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}}/api/groups/:serviceGroupId/services'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/groups/:serviceGroupId/services');

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}}/api/groups/:serviceGroupId/services'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/groups/:serviceGroupId/services';
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}}/api/groups/:serviceGroupId/services"]
                                                       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}}/api/groups/:serviceGroupId/services" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/groups/:serviceGroupId/services",
  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}}/api/groups/:serviceGroupId/services');

echo $response->getBody();

setUrl('{{baseUrl}}/api/groups/:serviceGroupId/services');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/groups/:serviceGroupId/services');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/groups/:serviceGroupId/services' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/groups/:serviceGroupId/services' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/groups/:serviceGroupId/services")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/groups/:serviceGroupId/services"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/groups/:serviceGroupId/services"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/groups/:serviceGroupId/services")

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/api/groups/:serviceGroupId/services') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/groups/:serviceGroupId/services";

    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}}/api/groups/:serviceGroupId/services

http GET {{baseUrl}}/api/groups/:serviceGroupId/services

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/groups/:serviceGroupId/services

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/groups/:serviceGroupId/services")! 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

[
  {
    "authorizedEntities": [
      "a string value"
    ],
    "clientId": "a string value",
    "clientName": "a string value",
    "clientSecret": "a string value",
    "dailyQuota": 123,
    "enabled": true,
    "metadata": {
      "key": "value"
    },
    "monthlyQuota": 123,
    "throttlingQuota": 123
  }
]

GET Get all services

{{baseUrl}}/api/services

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/services")

require "http/client"

url = "{{baseUrl}}/api/services"

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}}/api/services"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services"

	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/api/services HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/services")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services"))
    .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}}/api/services")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/services")
  .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}}/api/services');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services';
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}}/api/services',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/services")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services',
  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}}/api/services'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/services');

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}}/api/services'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services';
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}}/api/services"]
                                                       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}}/api/services" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services",
  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}}/api/services');

echo $response->getBody();

setUrl('{{baseUrl}}/api/services');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/services');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/services' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/services")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services")

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/api/services') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services";

    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}}/api/services

http GET {{baseUrl}}/api/services

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/services

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services")! 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

[
  {
    "additionalHeaders": {
      "key": "value"
    },
    "authConfigRef": "a string value",
    "buildMode": true,
    "clientValidatorRef": "a string value",
    "domain": "a string value",
    "enabled": true,
    "enforceSecureCommunication": true,
    "env": "a string value",
    "forceHttps": true,
    "groups": [
      "a string value"
    ],
    "headersVerification": {
      "key": "value"
    },
    "id": "110e8400-e29b-11d4-a716-446655440000",
    "localHost": "a string value",
    "localScheme": "a string value",
    "maintenanceMode": true,
    "matchingHeaders": {
      "key": "value"
    },
    "matchingRoot": "a string value",
    "metadata": {
      "key": "value"
    },
    "name": "a string value",
    "overrideHost": true,
    "privateApp": true,
    "redirectToLocal": true,
    "root": "a string value",
    "sendOtoroshiHeadersBack": true,
    "subdomain": "a string value",
    "transformerRef": "a string value",
    "userFacing": true,
    "xForwardedHeaders": true
  }
]

PATCH Update a service descriptor targets

{{baseUrl}}/api/services/:serviceId/targets

QUERY PARAMS

serviceId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/targets");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/services/:serviceId/targets" {:content-type :json
                                                                             :form-params [{:op ""
                                                                                            :path ""
                                                                                            :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/targets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/services/:serviceId/targets"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/services/:serviceId/targets");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/targets"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/services/:serviceId/targets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/services/:serviceId/targets")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/targets"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/targets")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/services/:serviceId/targets")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/services/:serviceId/targets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId/targets',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/targets';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services/:serviceId/targets',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/targets")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId/targets',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId/targets',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/services/:serviceId/targets');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId/targets',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/targets';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId/targets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/services/:serviceId/targets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/targets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/services/:serviceId/targets', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/targets');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId/targets');
$request->setRequestMethod('PATCH');
$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}}/api/services/:serviceId/targets' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/targets' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/services/:serviceId/targets", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/targets"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/targets"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId/targets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/services/:serviceId/targets') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId/targets";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/services/:serviceId/targets \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/services/:serviceId/targets \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/targets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/targets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

[
  {
    "host": "www.google.com",
    "scheme": "a string value"
  }
]

PATCH Update a service descriptor with a diff

{{baseUrl}}/api/services/:serviceId

QUERY PARAMS

serviceId

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId");

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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/services/:serviceId" {:content-type :json
                                                                     :form-params [{:op ""
                                                                                    :path ""
                                                                                    :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/services/:serviceId"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/services/:serviceId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/services/:serviceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/services/:serviceId")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/services/:serviceId")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/services/:serviceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services/:serviceId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/services/:serviceId',
  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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/services/:serviceId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/services/:serviceId',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/services/:serviceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/services/:serviceId', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId');
$request->setRequestMethod('PATCH');
$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}}/api/services/:serviceId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/services/:serviceId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/services/:serviceId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/services/:serviceId') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/services/:serviceId";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/services/:serviceId \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/services/:serviceId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "Canary": {
    "enabled": true,
    "root": "a string value",
    "traffic": 123123
  },
  "additionalHeaders": {
    "key": "value"
  },
  "api": {
    "exposeApi": true,
    "openApiDescriptorUrl": "http://www.google.com"
  },
  "authConfigRef": "a string value",
  "buildMode": true,
  "chaosConfig": {
    "enabled": true
  },
  "clientConfig": {
    "backoffFactor": 123123,
    "callTimeout": 123123,
    "globalTimeout": 123123,
    "maxErrors": 123123,
    "retries": 123123,
    "retryInitialDelay": 123123,
    "sampleInterval": 123123,
    "useCircuitBreaker": true
  },
  "clientValidatorRef": "a string value",
  "cors": {
    "allowCredentials": true,
    "allowOrigin": "a string value",
    "enabled": true,
    "maxAge": 123123
  },
  "domain": "a string value",
  "enabled": true,
  "enforceSecureCommunication": true,
  "env": "a string value",
  "forceHttps": true,
  "groups": [
    "a string value"
  ],
  "gzip": {
    "bufferSize": 123,
    "chunkedThreshold": 123,
    "compressionLevel": 123123,
    "enabled": true
  },
  "headersVerification": {
    "key": "value"
  },
  "healthCheck": {
    "enabled": true,
    "url": "http://www.google.com"
  },
  "id": "110e8400-e29b-11d4-a716-446655440000",
  "localHost": "a string value",
  "localScheme": "a string value",
  "maintenanceMode": true,
  "matchingHeaders": {
    "key": "value"
  },
  "matchingRoot": "a string value",
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "overrideHost": true,
  "privateApp": true,
  "privatePatterns": [
    "a string value"
  ],
  "publicPatterns": [
    "a string value"
  ],
  "redirectToLocal": true,
  "redirection": {
    "code": 123123,
    "enabled": true,
    "to": "a string value"
  },
  "root": "a string value",
  "secComExcludedPatterns": [
    "a string value"
  ],
  "sendOtoroshiHeadersBack": true,
  "statsdConfig": {
    "datadog": true,
    "host": "a string value",
    "port": 123123
  },
  "subdomain": "a string value",
  "transformerRef": "a string value",
  "userFacing": true,
  "xForwardedHeaders": true
}

PUT Update a service descriptor

{{baseUrl}}/api/services/:serviceId

QUERY PARAMS

serviceId

BODY json

{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId");

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  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/services/:serviceId" {:content-type :json
                                                                   :form-params {:Canary {:enabled false
                                                                                          :root ""
                                                                                          :targets [{:host ""
                                                                                                     :scheme ""}]
                                                                                          :traffic 0}
                                                                                 :additionalHeaders {}
                                                                                 :api {:exposeApi false
                                                                                       :openApiDescriptorUrl ""}
                                                                                 :authConfigRef ""
                                                                                 :buildMode false
                                                                                 :chaosConfig {:badResponsesFaultConfig {:ratio ""
                                                                                                                         :responses [{:body ""
                                                                                                                                      :headers {}
                                                                                                                                      :status 0}]}
                                                                                               :enabled false
                                                                                               :largeRequestFaultConfig {:additionalRequestSize 0
                                                                                                                         :ratio ""}
                                                                                               :largeResponseFaultConfig {:additionalRequestSize 0
                                                                                                                          :ratio ""}
                                                                                               :latencyInjectionFaultConfig {:from 0
                                                                                                                             :ratio ""
                                                                                                                             :to 0}}
                                                                                 :clientConfig {:backoffFactor 0
                                                                                                :callTimeout 0
                                                                                                :globalTimeout 0
                                                                                                :maxErrors 0
                                                                                                :retries 0
                                                                                                :retryInitialDelay 0
                                                                                                :sampleInterval 0
                                                                                                :useCircuitBreaker false}
                                                                                 :clientValidatorRef ""
                                                                                 :cors {:allowCredentials false
                                                                                        :allowHeaders []
                                                                                        :allowMethods []
                                                                                        :allowOrigin ""
                                                                                        :enabled false
                                                                                        :excludedPatterns []
                                                                                        :exposeHeaders []
                                                                                        :maxAge 0}
                                                                                 :domain ""
                                                                                 :enabled false
                                                                                 :enforceSecureCommunication false
                                                                                 :env ""
                                                                                 :forceHttps false
                                                                                 :groups []
                                                                                 :gzip {:blackList []
                                                                                        :bufferSize 0
                                                                                        :chunkedThreshold 0
                                                                                        :compressionLevel 0
                                                                                        :enabled false
                                                                                        :excludedPatterns []
                                                                                        :whiteList []}
                                                                                 :headersVerification {}
                                                                                 :healthCheck {:enabled false
                                                                                               :url ""}
                                                                                 :id ""
                                                                                 :ipFiltering {:blacklist []
                                                                                               :whitelist []}
                                                                                 :jwtVerifier ""
                                                                                 :localHost ""
                                                                                 :localScheme ""
                                                                                 :maintenanceMode false
                                                                                 :matchingHeaders {}
                                                                                 :matchingRoot ""
                                                                                 :metadata {}
                                                                                 :name ""
                                                                                 :overrideHost false
                                                                                 :privateApp false
                                                                                 :privatePatterns []
                                                                                 :publicPatterns []
                                                                                 :redirectToLocal false
                                                                                 :redirection {:code 0
                                                                                               :enabled false
                                                                                               :to ""}
                                                                                 :root ""
                                                                                 :secComExcludedPatterns []
                                                                                 :secComSettings ""
                                                                                 :sendOtoroshiHeadersBack false
                                                                                 :statsdConfig {:datadog false
                                                                                                :host ""
                                                                                                :port 0}
                                                                                 :subdomain ""
                                                                                 :targets [{}]
                                                                                 :transformerRef ""
                                                                                 :userFacing false
                                                                                 :xForwardedHeaders false}})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\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}}/api/services/:serviceId"),
    Content = new StringContent("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/services/:serviceId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId"

	payload := strings.NewReader("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\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/api/services/:serviceId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2405

{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/services/:serviceId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/services/:serviceId")
  .header("content-type", "application/json")
  .body("{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
  .asString();

const data = JSON.stringify({
  Canary: {
    enabled: false,
    root: '',
    targets: [
      {
        host: '',
        scheme: ''
      }
    ],
    traffic: 0
  },
  additionalHeaders: {},
  api: {
    exposeApi: false,
    openApiDescriptorUrl: ''
  },
  authConfigRef: '',
  buildMode: false,
  chaosConfig: {
    badResponsesFaultConfig: {
      ratio: '',
      responses: [
        {
          body: '',
          headers: {},
          status: 0
        }
      ]
    },
    enabled: false,
    largeRequestFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    largeResponseFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    latencyInjectionFaultConfig: {
      from: 0,
      ratio: '',
      to: 0
    }
  },
  clientConfig: {
    backoffFactor: 0,
    callTimeout: 0,
    globalTimeout: 0,
    maxErrors: 0,
    retries: 0,
    retryInitialDelay: 0,
    sampleInterval: 0,
    useCircuitBreaker: false
  },
  clientValidatorRef: '',
  cors: {
    allowCredentials: false,
    allowHeaders: [],
    allowMethods: [],
    allowOrigin: '',
    enabled: false,
    excludedPatterns: [],
    exposeHeaders: [],
    maxAge: 0
  },
  domain: '',
  enabled: false,
  enforceSecureCommunication: false,
  env: '',
  forceHttps: false,
  groups: [],
  gzip: {
    blackList: [],
    bufferSize: 0,
    chunkedThreshold: 0,
    compressionLevel: 0,
    enabled: false,
    excludedPatterns: [],
    whiteList: []
  },
  headersVerification: {},
  healthCheck: {
    enabled: false,
    url: ''
  },
  id: '',
  ipFiltering: {
    blacklist: [],
    whitelist: []
  },
  jwtVerifier: '',
  localHost: '',
  localScheme: '',
  maintenanceMode: false,
  matchingHeaders: {},
  matchingRoot: '',
  metadata: {},
  name: '',
  overrideHost: false,
  privateApp: false,
  privatePatterns: [],
  publicPatterns: [],
  redirectToLocal: false,
  redirection: {
    code: 0,
    enabled: false,
    to: ''
  },
  root: '',
  secComExcludedPatterns: [],
  secComSettings: '',
  sendOtoroshiHeadersBack: false,
  statsdConfig: {
    datadog: false,
    host: '',
    port: 0
  },
  subdomain: '',
  targets: [
    {}
  ],
  transformerRef: '',
  userFacing: false,
  xForwardedHeaders: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/services/:serviceId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/services/:serviceId',
  headers: {'content-type': 'application/json'},
  data: {
    Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
    additionalHeaders: {},
    api: {exposeApi: false, openApiDescriptorUrl: ''},
    authConfigRef: '',
    buildMode: false,
    chaosConfig: {
      badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
      enabled: false,
      largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
      largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
      latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
    },
    clientConfig: {
      backoffFactor: 0,
      callTimeout: 0,
      globalTimeout: 0,
      maxErrors: 0,
      retries: 0,
      retryInitialDelay: 0,
      sampleInterval: 0,
      useCircuitBreaker: false
    },
    clientValidatorRef: '',
    cors: {
      allowCredentials: false,
      allowHeaders: [],
      allowMethods: [],
      allowOrigin: '',
      enabled: false,
      excludedPatterns: [],
      exposeHeaders: [],
      maxAge: 0
    },
    domain: '',
    enabled: false,
    enforceSecureCommunication: false,
    env: '',
    forceHttps: false,
    groups: [],
    gzip: {
      blackList: [],
      bufferSize: 0,
      chunkedThreshold: 0,
      compressionLevel: 0,
      enabled: false,
      excludedPatterns: [],
      whiteList: []
    },
    headersVerification: {},
    healthCheck: {enabled: false, url: ''},
    id: '',
    ipFiltering: {blacklist: [], whitelist: []},
    jwtVerifier: '',
    localHost: '',
    localScheme: '',
    maintenanceMode: false,
    matchingHeaders: {},
    matchingRoot: '',
    metadata: {},
    name: '',
    overrideHost: false,
    privateApp: false,
    privatePatterns: [],
    publicPatterns: [],
    redirectToLocal: false,
    redirection: {code: 0, enabled: false, to: ''},
    root: '',
    secComExcludedPatterns: [],
    secComSettings: '',
    sendOtoroshiHeadersBack: false,
    statsdConfig: {datadog: false, host: '', port: 0},
    subdomain: '',
    targets: [{}],
    transformerRef: '',
    userFacing: false,
    xForwardedHeaders: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{"blacklist":[],"whitelist":[]},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services/:serviceId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Canary": {\n    "enabled": false,\n    "root": "",\n    "targets": [\n      {\n        "host": "",\n        "scheme": ""\n      }\n    ],\n    "traffic": 0\n  },\n  "additionalHeaders": {},\n  "api": {\n    "exposeApi": false,\n    "openApiDescriptorUrl": ""\n  },\n  "authConfigRef": "",\n  "buildMode": false,\n  "chaosConfig": {\n    "badResponsesFaultConfig": {\n      "ratio": "",\n      "responses": [\n        {\n          "body": "",\n          "headers": {},\n          "status": 0\n        }\n      ]\n    },\n    "enabled": false,\n    "largeRequestFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "largeResponseFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "latencyInjectionFaultConfig": {\n      "from": 0,\n      "ratio": "",\n      "to": 0\n    }\n  },\n  "clientConfig": {\n    "backoffFactor": 0,\n    "callTimeout": 0,\n    "globalTimeout": 0,\n    "maxErrors": 0,\n    "retries": 0,\n    "retryInitialDelay": 0,\n    "sampleInterval": 0,\n    "useCircuitBreaker": false\n  },\n  "clientValidatorRef": "",\n  "cors": {\n    "allowCredentials": false,\n    "allowHeaders": [],\n    "allowMethods": [],\n    "allowOrigin": "",\n    "enabled": false,\n    "excludedPatterns": [],\n    "exposeHeaders": [],\n    "maxAge": 0\n  },\n  "domain": "",\n  "enabled": false,\n  "enforceSecureCommunication": false,\n  "env": "",\n  "forceHttps": false,\n  "groups": [],\n  "gzip": {\n    "blackList": [],\n    "bufferSize": 0,\n    "chunkedThreshold": 0,\n    "compressionLevel": 0,\n    "enabled": false,\n    "excludedPatterns": [],\n    "whiteList": []\n  },\n  "headersVerification": {},\n  "healthCheck": {\n    "enabled": false,\n    "url": ""\n  },\n  "id": "",\n  "ipFiltering": {\n    "blacklist": [],\n    "whitelist": []\n  },\n  "jwtVerifier": "",\n  "localHost": "",\n  "localScheme": "",\n  "maintenanceMode": false,\n  "matchingHeaders": {},\n  "matchingRoot": "",\n  "metadata": {},\n  "name": "",\n  "overrideHost": false,\n  "privateApp": false,\n  "privatePatterns": [],\n  "publicPatterns": [],\n  "redirectToLocal": false,\n  "redirection": {\n    "code": 0,\n    "enabled": false,\n    "to": ""\n  },\n  "root": "",\n  "secComExcludedPatterns": [],\n  "secComSettings": "",\n  "sendOtoroshiHeadersBack": false,\n  "statsdConfig": {\n    "datadog": false,\n    "host": "",\n    "port": 0\n  },\n  "subdomain": "",\n  "targets": [\n    {}\n  ],\n  "transformerRef": "",\n  "userFacing": false,\n  "xForwardedHeaders": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId")
  .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/api/services/:serviceId',
  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({
  Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
  additionalHeaders: {},
  api: {exposeApi: false, openApiDescriptorUrl: ''},
  authConfigRef: '',
  buildMode: false,
  chaosConfig: {
    badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
    enabled: false,
    largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
    largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
    latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
  },
  clientConfig: {
    backoffFactor: 0,
    callTimeout: 0,
    globalTimeout: 0,
    maxErrors: 0,
    retries: 0,
    retryInitialDelay: 0,
    sampleInterval: 0,
    useCircuitBreaker: false
  },
  clientValidatorRef: '',
  cors: {
    allowCredentials: false,
    allowHeaders: [],
    allowMethods: [],
    allowOrigin: '',
    enabled: false,
    excludedPatterns: [],
    exposeHeaders: [],
    maxAge: 0
  },
  domain: '',
  enabled: false,
  enforceSecureCommunication: false,
  env: '',
  forceHttps: false,
  groups: [],
  gzip: {
    blackList: [],
    bufferSize: 0,
    chunkedThreshold: 0,
    compressionLevel: 0,
    enabled: false,
    excludedPatterns: [],
    whiteList: []
  },
  headersVerification: {},
  healthCheck: {enabled: false, url: ''},
  id: '',
  ipFiltering: {blacklist: [], whitelist: []},
  jwtVerifier: '',
  localHost: '',
  localScheme: '',
  maintenanceMode: false,
  matchingHeaders: {},
  matchingRoot: '',
  metadata: {},
  name: '',
  overrideHost: false,
  privateApp: false,
  privatePatterns: [],
  publicPatterns: [],
  redirectToLocal: false,
  redirection: {code: 0, enabled: false, to: ''},
  root: '',
  secComExcludedPatterns: [],
  secComSettings: '',
  sendOtoroshiHeadersBack: false,
  statsdConfig: {datadog: false, host: '', port: 0},
  subdomain: '',
  targets: [{}],
  transformerRef: '',
  userFacing: false,
  xForwardedHeaders: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/services/:serviceId',
  headers: {'content-type': 'application/json'},
  body: {
    Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
    additionalHeaders: {},
    api: {exposeApi: false, openApiDescriptorUrl: ''},
    authConfigRef: '',
    buildMode: false,
    chaosConfig: {
      badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
      enabled: false,
      largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
      largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
      latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
    },
    clientConfig: {
      backoffFactor: 0,
      callTimeout: 0,
      globalTimeout: 0,
      maxErrors: 0,
      retries: 0,
      retryInitialDelay: 0,
      sampleInterval: 0,
      useCircuitBreaker: false
    },
    clientValidatorRef: '',
    cors: {
      allowCredentials: false,
      allowHeaders: [],
      allowMethods: [],
      allowOrigin: '',
      enabled: false,
      excludedPatterns: [],
      exposeHeaders: [],
      maxAge: 0
    },
    domain: '',
    enabled: false,
    enforceSecureCommunication: false,
    env: '',
    forceHttps: false,
    groups: [],
    gzip: {
      blackList: [],
      bufferSize: 0,
      chunkedThreshold: 0,
      compressionLevel: 0,
      enabled: false,
      excludedPatterns: [],
      whiteList: []
    },
    headersVerification: {},
    healthCheck: {enabled: false, url: ''},
    id: '',
    ipFiltering: {blacklist: [], whitelist: []},
    jwtVerifier: '',
    localHost: '',
    localScheme: '',
    maintenanceMode: false,
    matchingHeaders: {},
    matchingRoot: '',
    metadata: {},
    name: '',
    overrideHost: false,
    privateApp: false,
    privatePatterns: [],
    publicPatterns: [],
    redirectToLocal: false,
    redirection: {code: 0, enabled: false, to: ''},
    root: '',
    secComExcludedPatterns: [],
    secComSettings: '',
    sendOtoroshiHeadersBack: false,
    statsdConfig: {datadog: false, host: '', port: 0},
    subdomain: '',
    targets: [{}],
    transformerRef: '',
    userFacing: false,
    xForwardedHeaders: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/services/:serviceId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Canary: {
    enabled: false,
    root: '',
    targets: [
      {
        host: '',
        scheme: ''
      }
    ],
    traffic: 0
  },
  additionalHeaders: {},
  api: {
    exposeApi: false,
    openApiDescriptorUrl: ''
  },
  authConfigRef: '',
  buildMode: false,
  chaosConfig: {
    badResponsesFaultConfig: {
      ratio: '',
      responses: [
        {
          body: '',
          headers: {},
          status: 0
        }
      ]
    },
    enabled: false,
    largeRequestFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    largeResponseFaultConfig: {
      additionalRequestSize: 0,
      ratio: ''
    },
    latencyInjectionFaultConfig: {
      from: 0,
      ratio: '',
      to: 0
    }
  },
  clientConfig: {
    backoffFactor: 0,
    callTimeout: 0,
    globalTimeout: 0,
    maxErrors: 0,
    retries: 0,
    retryInitialDelay: 0,
    sampleInterval: 0,
    useCircuitBreaker: false
  },
  clientValidatorRef: '',
  cors: {
    allowCredentials: false,
    allowHeaders: [],
    allowMethods: [],
    allowOrigin: '',
    enabled: false,
    excludedPatterns: [],
    exposeHeaders: [],
    maxAge: 0
  },
  domain: '',
  enabled: false,
  enforceSecureCommunication: false,
  env: '',
  forceHttps: false,
  groups: [],
  gzip: {
    blackList: [],
    bufferSize: 0,
    chunkedThreshold: 0,
    compressionLevel: 0,
    enabled: false,
    excludedPatterns: [],
    whiteList: []
  },
  headersVerification: {},
  healthCheck: {
    enabled: false,
    url: ''
  },
  id: '',
  ipFiltering: {
    blacklist: [],
    whitelist: []
  },
  jwtVerifier: '',
  localHost: '',
  localScheme: '',
  maintenanceMode: false,
  matchingHeaders: {},
  matchingRoot: '',
  metadata: {},
  name: '',
  overrideHost: false,
  privateApp: false,
  privatePatterns: [],
  publicPatterns: [],
  redirectToLocal: false,
  redirection: {
    code: 0,
    enabled: false,
    to: ''
  },
  root: '',
  secComExcludedPatterns: [],
  secComSettings: '',
  sendOtoroshiHeadersBack: false,
  statsdConfig: {
    datadog: false,
    host: '',
    port: 0
  },
  subdomain: '',
  targets: [
    {}
  ],
  transformerRef: '',
  userFacing: false,
  xForwardedHeaders: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/services/:serviceId',
  headers: {'content-type': 'application/json'},
  data: {
    Canary: {enabled: false, root: '', targets: [{host: '', scheme: ''}], traffic: 0},
    additionalHeaders: {},
    api: {exposeApi: false, openApiDescriptorUrl: ''},
    authConfigRef: '',
    buildMode: false,
    chaosConfig: {
      badResponsesFaultConfig: {ratio: '', responses: [{body: '', headers: {}, status: 0}]},
      enabled: false,
      largeRequestFaultConfig: {additionalRequestSize: 0, ratio: ''},
      largeResponseFaultConfig: {additionalRequestSize: 0, ratio: ''},
      latencyInjectionFaultConfig: {from: 0, ratio: '', to: 0}
    },
    clientConfig: {
      backoffFactor: 0,
      callTimeout: 0,
      globalTimeout: 0,
      maxErrors: 0,
      retries: 0,
      retryInitialDelay: 0,
      sampleInterval: 0,
      useCircuitBreaker: false
    },
    clientValidatorRef: '',
    cors: {
      allowCredentials: false,
      allowHeaders: [],
      allowMethods: [],
      allowOrigin: '',
      enabled: false,
      excludedPatterns: [],
      exposeHeaders: [],
      maxAge: 0
    },
    domain: '',
    enabled: false,
    enforceSecureCommunication: false,
    env: '',
    forceHttps: false,
    groups: [],
    gzip: {
      blackList: [],
      bufferSize: 0,
      chunkedThreshold: 0,
      compressionLevel: 0,
      enabled: false,
      excludedPatterns: [],
      whiteList: []
    },
    headersVerification: {},
    healthCheck: {enabled: false, url: ''},
    id: '',
    ipFiltering: {blacklist: [], whitelist: []},
    jwtVerifier: '',
    localHost: '',
    localScheme: '',
    maintenanceMode: false,
    matchingHeaders: {},
    matchingRoot: '',
    metadata: {},
    name: '',
    overrideHost: false,
    privateApp: false,
    privatePatterns: [],
    publicPatterns: [],
    redirectToLocal: false,
    redirection: {code: 0, enabled: false, to: ''},
    root: '',
    secComExcludedPatterns: [],
    secComSettings: '',
    sendOtoroshiHeadersBack: false,
    statsdConfig: {datadog: false, host: '', port: 0},
    subdomain: '',
    targets: [{}],
    transformerRef: '',
    userFacing: false,
    xForwardedHeaders: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Canary":{"enabled":false,"root":"","targets":[{"host":"","scheme":""}],"traffic":0},"additionalHeaders":{},"api":{"exposeApi":false,"openApiDescriptorUrl":""},"authConfigRef":"","buildMode":false,"chaosConfig":{"badResponsesFaultConfig":{"ratio":"","responses":[{"body":"","headers":{},"status":0}]},"enabled":false,"largeRequestFaultConfig":{"additionalRequestSize":0,"ratio":""},"largeResponseFaultConfig":{"additionalRequestSize":0,"ratio":""},"latencyInjectionFaultConfig":{"from":0,"ratio":"","to":0}},"clientConfig":{"backoffFactor":0,"callTimeout":0,"globalTimeout":0,"maxErrors":0,"retries":0,"retryInitialDelay":0,"sampleInterval":0,"useCircuitBreaker":false},"clientValidatorRef":"","cors":{"allowCredentials":false,"allowHeaders":[],"allowMethods":[],"allowOrigin":"","enabled":false,"excludedPatterns":[],"exposeHeaders":[],"maxAge":0},"domain":"","enabled":false,"enforceSecureCommunication":false,"env":"","forceHttps":false,"groups":[],"gzip":{"blackList":[],"bufferSize":0,"chunkedThreshold":0,"compressionLevel":0,"enabled":false,"excludedPatterns":[],"whiteList":[]},"headersVerification":{},"healthCheck":{"enabled":false,"url":""},"id":"","ipFiltering":{"blacklist":[],"whitelist":[]},"jwtVerifier":"","localHost":"","localScheme":"","maintenanceMode":false,"matchingHeaders":{},"matchingRoot":"","metadata":{},"name":"","overrideHost":false,"privateApp":false,"privatePatterns":[],"publicPatterns":[],"redirectToLocal":false,"redirection":{"code":0,"enabled":false,"to":""},"root":"","secComExcludedPatterns":[],"secComSettings":"","sendOtoroshiHeadersBack":false,"statsdConfig":{"datadog":false,"host":"","port":0},"subdomain":"","targets":[{}],"transformerRef":"","userFacing":false,"xForwardedHeaders":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Canary": @{ @"enabled": @NO, @"root": @"", @"targets": @[ @{ @"host": @"", @"scheme": @"" } ], @"traffic": @0 },
                              @"additionalHeaders": @{  },
                              @"api": @{ @"exposeApi": @NO, @"openApiDescriptorUrl": @"" },
                              @"authConfigRef": @"",
                              @"buildMode": @NO,
                              @"chaosConfig": @{ @"badResponsesFaultConfig": @{ @"ratio": @"", @"responses": @[ @{ @"body": @"", @"headers": @{  }, @"status": @0 } ] }, @"enabled": @NO, @"largeRequestFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"largeResponseFaultConfig": @{ @"additionalRequestSize": @0, @"ratio": @"" }, @"latencyInjectionFaultConfig": @{ @"from": @0, @"ratio": @"", @"to": @0 } },
                              @"clientConfig": @{ @"backoffFactor": @0, @"callTimeout": @0, @"globalTimeout": @0, @"maxErrors": @0, @"retries": @0, @"retryInitialDelay": @0, @"sampleInterval": @0, @"useCircuitBreaker": @NO },
                              @"clientValidatorRef": @"",
                              @"cors": @{ @"allowCredentials": @NO, @"allowHeaders": @[  ], @"allowMethods": @[  ], @"allowOrigin": @"", @"enabled": @NO, @"excludedPatterns": @[  ], @"exposeHeaders": @[  ], @"maxAge": @0 },
                              @"domain": @"",
                              @"enabled": @NO,
                              @"enforceSecureCommunication": @NO,
                              @"env": @"",
                              @"forceHttps": @NO,
                              @"groups": @[  ],
                              @"gzip": @{ @"blackList": @[  ], @"bufferSize": @0, @"chunkedThreshold": @0, @"compressionLevel": @0, @"enabled": @NO, @"excludedPatterns": @[  ], @"whiteList": @[  ] },
                              @"headersVerification": @{  },
                              @"healthCheck": @{ @"enabled": @NO, @"url": @"" },
                              @"id": @"",
                              @"ipFiltering": @{ @"blacklist": @[  ], @"whitelist": @[  ] },
                              @"jwtVerifier": @"",
                              @"localHost": @"",
                              @"localScheme": @"",
                              @"maintenanceMode": @NO,
                              @"matchingHeaders": @{  },
                              @"matchingRoot": @"",
                              @"metadata": @{  },
                              @"name": @"",
                              @"overrideHost": @NO,
                              @"privateApp": @NO,
                              @"privatePatterns": @[  ],
                              @"publicPatterns": @[  ],
                              @"redirectToLocal": @NO,
                              @"redirection": @{ @"code": @0, @"enabled": @NO, @"to": @"" },
                              @"root": @"",
                              @"secComExcludedPatterns": @[  ],
                              @"secComSettings": @"",
                              @"sendOtoroshiHeadersBack": @NO,
                              @"statsdConfig": @{ @"datadog": @NO, @"host": @"", @"port": @0 },
                              @"subdomain": @"",
                              @"targets": @[ @{  } ],
                              @"transformerRef": @"",
                              @"userFacing": @NO,
                              @"xForwardedHeaders": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId"]
                                                       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}}/api/services/:serviceId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId",
  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([
    'Canary' => [
        'enabled' => null,
        'root' => '',
        'targets' => [
                [
                                'host' => '',
                                'scheme' => ''
                ]
        ],
        'traffic' => 0
    ],
    'additionalHeaders' => [
        
    ],
    'api' => [
        'exposeApi' => null,
        'openApiDescriptorUrl' => ''
    ],
    'authConfigRef' => '',
    'buildMode' => null,
    'chaosConfig' => [
        'badResponsesFaultConfig' => [
                'ratio' => '',
                'responses' => [
                                [
                                                                'body' => '',
                                                                'headers' => [
                                                                                                                                
                                                                ],
                                                                'status' => 0
                                ]
                ]
        ],
        'enabled' => null,
        'largeRequestFaultConfig' => [
                'additionalRequestSize' => 0,
                'ratio' => ''
        ],
        'largeResponseFaultConfig' => [
                'additionalRequestSize' => 0,
                'ratio' => ''
        ],
        'latencyInjectionFaultConfig' => [
                'from' => 0,
                'ratio' => '',
                'to' => 0
        ]
    ],
    'clientConfig' => [
        'backoffFactor' => 0,
        'callTimeout' => 0,
        'globalTimeout' => 0,
        'maxErrors' => 0,
        'retries' => 0,
        'retryInitialDelay' => 0,
        'sampleInterval' => 0,
        'useCircuitBreaker' => null
    ],
    'clientValidatorRef' => '',
    'cors' => [
        'allowCredentials' => null,
        'allowHeaders' => [
                
        ],
        'allowMethods' => [
                
        ],
        'allowOrigin' => '',
        'enabled' => null,
        'excludedPatterns' => [
                
        ],
        'exposeHeaders' => [
                
        ],
        'maxAge' => 0
    ],
    'domain' => '',
    'enabled' => null,
    'enforceSecureCommunication' => null,
    'env' => '',
    'forceHttps' => null,
    'groups' => [
        
    ],
    'gzip' => [
        'blackList' => [
                
        ],
        'bufferSize' => 0,
        'chunkedThreshold' => 0,
        'compressionLevel' => 0,
        'enabled' => null,
        'excludedPatterns' => [
                
        ],
        'whiteList' => [
                
        ]
    ],
    'headersVerification' => [
        
    ],
    'healthCheck' => [
        'enabled' => null,
        'url' => ''
    ],
    'id' => '',
    'ipFiltering' => [
        'blacklist' => [
                
        ],
        'whitelist' => [
                
        ]
    ],
    'jwtVerifier' => '',
    'localHost' => '',
    'localScheme' => '',
    'maintenanceMode' => null,
    'matchingHeaders' => [
        
    ],
    'matchingRoot' => '',
    'metadata' => [
        
    ],
    'name' => '',
    'overrideHost' => null,
    'privateApp' => null,
    'privatePatterns' => [
        
    ],
    'publicPatterns' => [
        
    ],
    'redirectToLocal' => null,
    'redirection' => [
        'code' => 0,
        'enabled' => null,
        'to' => ''
    ],
    'root' => '',
    'secComExcludedPatterns' => [
        
    ],
    'secComSettings' => '',
    'sendOtoroshiHeadersBack' => null,
    'statsdConfig' => [
        'datadog' => null,
        'host' => '',
        'port' => 0
    ],
    'subdomain' => '',
    'targets' => [
        [
                
        ]
    ],
    'transformerRef' => '',
    'userFacing' => null,
    'xForwardedHeaders' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/services/:serviceId', [
  'body' => '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Canary' => [
    'enabled' => null,
    'root' => '',
    'targets' => [
        [
                'host' => '',
                'scheme' => ''
        ]
    ],
    'traffic' => 0
  ],
  'additionalHeaders' => [
    
  ],
  'api' => [
    'exposeApi' => null,
    'openApiDescriptorUrl' => ''
  ],
  'authConfigRef' => '',
  'buildMode' => null,
  'chaosConfig' => [
    'badResponsesFaultConfig' => [
        'ratio' => '',
        'responses' => [
                [
                                'body' => '',
                                'headers' => [
                                                                
                                ],
                                'status' => 0
                ]
        ]
    ],
    'enabled' => null,
    'largeRequestFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'largeResponseFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'latencyInjectionFaultConfig' => [
        'from' => 0,
        'ratio' => '',
        'to' => 0
    ]
  ],
  'clientConfig' => [
    'backoffFactor' => 0,
    'callTimeout' => 0,
    'globalTimeout' => 0,
    'maxErrors' => 0,
    'retries' => 0,
    'retryInitialDelay' => 0,
    'sampleInterval' => 0,
    'useCircuitBreaker' => null
  ],
  'clientValidatorRef' => '',
  'cors' => [
    'allowCredentials' => null,
    'allowHeaders' => [
        
    ],
    'allowMethods' => [
        
    ],
    'allowOrigin' => '',
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'exposeHeaders' => [
        
    ],
    'maxAge' => 0
  ],
  'domain' => '',
  'enabled' => null,
  'enforceSecureCommunication' => null,
  'env' => '',
  'forceHttps' => null,
  'groups' => [
    
  ],
  'gzip' => [
    'blackList' => [
        
    ],
    'bufferSize' => 0,
    'chunkedThreshold' => 0,
    'compressionLevel' => 0,
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'whiteList' => [
        
    ]
  ],
  'headersVerification' => [
    
  ],
  'healthCheck' => [
    'enabled' => null,
    'url' => ''
  ],
  'id' => '',
  'ipFiltering' => [
    'blacklist' => [
        
    ],
    'whitelist' => [
        
    ]
  ],
  'jwtVerifier' => '',
  'localHost' => '',
  'localScheme' => '',
  'maintenanceMode' => null,
  'matchingHeaders' => [
    
  ],
  'matchingRoot' => '',
  'metadata' => [
    
  ],
  'name' => '',
  'overrideHost' => null,
  'privateApp' => null,
  'privatePatterns' => [
    
  ],
  'publicPatterns' => [
    
  ],
  'redirectToLocal' => null,
  'redirection' => [
    'code' => 0,
    'enabled' => null,
    'to' => ''
  ],
  'root' => '',
  'secComExcludedPatterns' => [
    
  ],
  'secComSettings' => '',
  'sendOtoroshiHeadersBack' => null,
  'statsdConfig' => [
    'datadog' => null,
    'host' => '',
    'port' => 0
  ],
  'subdomain' => '',
  'targets' => [
    [
        
    ]
  ],
  'transformerRef' => '',
  'userFacing' => null,
  'xForwardedHeaders' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Canary' => [
    'enabled' => null,
    'root' => '',
    'targets' => [
        [
                'host' => '',
                'scheme' => ''
        ]
    ],
    'traffic' => 0
  ],
  'additionalHeaders' => [
    
  ],
  'api' => [
    'exposeApi' => null,
    'openApiDescriptorUrl' => ''
  ],
  'authConfigRef' => '',
  'buildMode' => null,
  'chaosConfig' => [
    'badResponsesFaultConfig' => [
        'ratio' => '',
        'responses' => [
                [
                                'body' => '',
                                'headers' => [
                                                                
                                ],
                                'status' => 0
                ]
        ]
    ],
    'enabled' => null,
    'largeRequestFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'largeResponseFaultConfig' => [
        'additionalRequestSize' => 0,
        'ratio' => ''
    ],
    'latencyInjectionFaultConfig' => [
        'from' => 0,
        'ratio' => '',
        'to' => 0
    ]
  ],
  'clientConfig' => [
    'backoffFactor' => 0,
    'callTimeout' => 0,
    'globalTimeout' => 0,
    'maxErrors' => 0,
    'retries' => 0,
    'retryInitialDelay' => 0,
    'sampleInterval' => 0,
    'useCircuitBreaker' => null
  ],
  'clientValidatorRef' => '',
  'cors' => [
    'allowCredentials' => null,
    'allowHeaders' => [
        
    ],
    'allowMethods' => [
        
    ],
    'allowOrigin' => '',
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'exposeHeaders' => [
        
    ],
    'maxAge' => 0
  ],
  'domain' => '',
  'enabled' => null,
  'enforceSecureCommunication' => null,
  'env' => '',
  'forceHttps' => null,
  'groups' => [
    
  ],
  'gzip' => [
    'blackList' => [
        
    ],
    'bufferSize' => 0,
    'chunkedThreshold' => 0,
    'compressionLevel' => 0,
    'enabled' => null,
    'excludedPatterns' => [
        
    ],
    'whiteList' => [
        
    ]
  ],
  'headersVerification' => [
    
  ],
  'healthCheck' => [
    'enabled' => null,
    'url' => ''
  ],
  'id' => '',
  'ipFiltering' => [
    'blacklist' => [
        
    ],
    'whitelist' => [
        
    ]
  ],
  'jwtVerifier' => '',
  'localHost' => '',
  'localScheme' => '',
  'maintenanceMode' => null,
  'matchingHeaders' => [
    
  ],
  'matchingRoot' => '',
  'metadata' => [
    
  ],
  'name' => '',
  'overrideHost' => null,
  'privateApp' => null,
  'privatePatterns' => [
    
  ],
  'publicPatterns' => [
    
  ],
  'redirectToLocal' => null,
  'redirection' => [
    'code' => 0,
    'enabled' => null,
    'to' => ''
  ],
  'root' => '',
  'secComExcludedPatterns' => [
    
  ],
  'secComSettings' => '',
  'sendOtoroshiHeadersBack' => null,
  'statsdConfig' => [
    'datadog' => null,
    'host' => '',
    'port' => 0
  ],
  'subdomain' => '',
  'targets' => [
    [
        
    ]
  ],
  'transformerRef' => '',
  'userFacing' => null,
  'xForwardedHeaders' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId');
$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}}/api/services/:serviceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/services/:serviceId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId"

payload = {
    "Canary": {
        "enabled": False,
        "root": "",
        "targets": [
            {
                "host": "",
                "scheme": ""
            }
        ],
        "traffic": 0
    },
    "additionalHeaders": {},
    "api": {
        "exposeApi": False,
        "openApiDescriptorUrl": ""
    },
    "authConfigRef": "",
    "buildMode": False,
    "chaosConfig": {
        "badResponsesFaultConfig": {
            "ratio": "",
            "responses": [
                {
                    "body": "",
                    "headers": {},
                    "status": 0
                }
            ]
        },
        "enabled": False,
        "largeRequestFaultConfig": {
            "additionalRequestSize": 0,
            "ratio": ""
        },
        "largeResponseFaultConfig": {
            "additionalRequestSize": 0,
            "ratio": ""
        },
        "latencyInjectionFaultConfig": {
            "from": 0,
            "ratio": "",
            "to": 0
        }
    },
    "clientConfig": {
        "backoffFactor": 0,
        "callTimeout": 0,
        "globalTimeout": 0,
        "maxErrors": 0,
        "retries": 0,
        "retryInitialDelay": 0,
        "sampleInterval": 0,
        "useCircuitBreaker": False
    },
    "clientValidatorRef": "",
    "cors": {
        "allowCredentials": False,
        "allowHeaders": [],
        "allowMethods": [],
        "allowOrigin": "",
        "enabled": False,
        "excludedPatterns": [],
        "exposeHeaders": [],
        "maxAge": 0
    },
    "domain": "",
    "enabled": False,
    "enforceSecureCommunication": False,
    "env": "",
    "forceHttps": False,
    "groups": [],
    "gzip": {
        "blackList": [],
        "bufferSize": 0,
        "chunkedThreshold": 0,
        "compressionLevel": 0,
        "enabled": False,
        "excludedPatterns": [],
        "whiteList": []
    },
    "headersVerification": {},
    "healthCheck": {
        "enabled": False,
        "url": ""
    },
    "id": "",
    "ipFiltering": {
        "blacklist": [],
        "whitelist": []
    },
    "jwtVerifier": "",
    "localHost": "",
    "localScheme": "",
    "maintenanceMode": False,
    "matchingHeaders": {},
    "matchingRoot": "",
    "metadata": {},
    "name": "",
    "overrideHost": False,
    "privateApp": False,
    "privatePatterns": [],
    "publicPatterns": [],
    "redirectToLocal": False,
    "redirection": {
        "code": 0,
        "enabled": False,
        "to": ""
    },
    "root": "",
    "secComExcludedPatterns": [],
    "secComSettings": "",
    "sendOtoroshiHeadersBack": False,
    "statsdConfig": {
        "datadog": False,
        "host": "",
        "port": 0
    },
    "subdomain": "",
    "targets": [{}],
    "transformerRef": "",
    "userFacing": False,
    "xForwardedHeaders": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId"

payload <- "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\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}}/api/services/:serviceId")

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  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/api/services/:serviceId') do |req|
  req.body = "{\n  \"Canary\": {\n    \"enabled\": false,\n    \"root\": \"\",\n    \"targets\": [\n      {\n        \"host\": \"\",\n        \"scheme\": \"\"\n      }\n    ],\n    \"traffic\": 0\n  },\n  \"additionalHeaders\": {},\n  \"api\": {\n    \"exposeApi\": false,\n    \"openApiDescriptorUrl\": \"\"\n  },\n  \"authConfigRef\": \"\",\n  \"buildMode\": false,\n  \"chaosConfig\": {\n    \"badResponsesFaultConfig\": {\n      \"ratio\": \"\",\n      \"responses\": [\n        {\n          \"body\": \"\",\n          \"headers\": {},\n          \"status\": 0\n        }\n      ]\n    },\n    \"enabled\": false,\n    \"largeRequestFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"largeResponseFaultConfig\": {\n      \"additionalRequestSize\": 0,\n      \"ratio\": \"\"\n    },\n    \"latencyInjectionFaultConfig\": {\n      \"from\": 0,\n      \"ratio\": \"\",\n      \"to\": 0\n    }\n  },\n  \"clientConfig\": {\n    \"backoffFactor\": 0,\n    \"callTimeout\": 0,\n    \"globalTimeout\": 0,\n    \"maxErrors\": 0,\n    \"retries\": 0,\n    \"retryInitialDelay\": 0,\n    \"sampleInterval\": 0,\n    \"useCircuitBreaker\": false\n  },\n  \"clientValidatorRef\": \"\",\n  \"cors\": {\n    \"allowCredentials\": false,\n    \"allowHeaders\": [],\n    \"allowMethods\": [],\n    \"allowOrigin\": \"\",\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"exposeHeaders\": [],\n    \"maxAge\": 0\n  },\n  \"domain\": \"\",\n  \"enabled\": false,\n  \"enforceSecureCommunication\": false,\n  \"env\": \"\",\n  \"forceHttps\": false,\n  \"groups\": [],\n  \"gzip\": {\n    \"blackList\": [],\n    \"bufferSize\": 0,\n    \"chunkedThreshold\": 0,\n    \"compressionLevel\": 0,\n    \"enabled\": false,\n    \"excludedPatterns\": [],\n    \"whiteList\": []\n  },\n  \"headersVerification\": {},\n  \"healthCheck\": {\n    \"enabled\": false,\n    \"url\": \"\"\n  },\n  \"id\": \"\",\n  \"ipFiltering\": {\n    \"blacklist\": [],\n    \"whitelist\": []\n  },\n  \"jwtVerifier\": \"\",\n  \"localHost\": \"\",\n  \"localScheme\": \"\",\n  \"maintenanceMode\": false,\n  \"matchingHeaders\": {},\n  \"matchingRoot\": \"\",\n  \"metadata\": {},\n  \"name\": \"\",\n  \"overrideHost\": false,\n  \"privateApp\": false,\n  \"privatePatterns\": [],\n  \"publicPatterns\": [],\n  \"redirectToLocal\": false,\n  \"redirection\": {\n    \"code\": 0,\n    \"enabled\": false,\n    \"to\": \"\"\n  },\n  \"root\": \"\",\n  \"secComExcludedPatterns\": [],\n  \"secComSettings\": \"\",\n  \"sendOtoroshiHeadersBack\": false,\n  \"statsdConfig\": {\n    \"datadog\": false,\n    \"host\": \"\",\n    \"port\": 0\n  },\n  \"subdomain\": \"\",\n  \"targets\": [\n    {}\n  ],\n  \"transformerRef\": \"\",\n  \"userFacing\": false,\n  \"xForwardedHeaders\": false\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}}/api/services/:serviceId";

    let payload = json!({
        "Canary": json!({
            "enabled": false,
            "root": "",
            "targets": (
                json!({
                    "host": "",
                    "scheme": ""
                })
            ),
            "traffic": 0
        }),
        "additionalHeaders": json!({}),
        "api": json!({
            "exposeApi": false,
            "openApiDescriptorUrl": ""
        }),
        "authConfigRef": "",
        "buildMode": false,
        "chaosConfig": json!({
            "badResponsesFaultConfig": json!({
                "ratio": "",
                "responses": (
                    json!({
                        "body": "",
                        "headers": json!({}),
                        "status": 0
                    })
                )
            }),
            "enabled": false,
            "largeRequestFaultConfig": json!({
                "additionalRequestSize": 0,
                "ratio": ""
            }),
            "largeResponseFaultConfig": json!({
                "additionalRequestSize": 0,
                "ratio": ""
            }),
            "latencyInjectionFaultConfig": json!({
                "from": 0,
                "ratio": "",
                "to": 0
            })
        }),
        "clientConfig": json!({
            "backoffFactor": 0,
            "callTimeout": 0,
            "globalTimeout": 0,
            "maxErrors": 0,
            "retries": 0,
            "retryInitialDelay": 0,
            "sampleInterval": 0,
            "useCircuitBreaker": false
        }),
        "clientValidatorRef": "",
        "cors": json!({
            "allowCredentials": false,
            "allowHeaders": (),
            "allowMethods": (),
            "allowOrigin": "",
            "enabled": false,
            "excludedPatterns": (),
            "exposeHeaders": (),
            "maxAge": 0
        }),
        "domain": "",
        "enabled": false,
        "enforceSecureCommunication": false,
        "env": "",
        "forceHttps": false,
        "groups": (),
        "gzip": json!({
            "blackList": (),
            "bufferSize": 0,
            "chunkedThreshold": 0,
            "compressionLevel": 0,
            "enabled": false,
            "excludedPatterns": (),
            "whiteList": ()
        }),
        "headersVerification": json!({}),
        "healthCheck": json!({
            "enabled": false,
            "url": ""
        }),
        "id": "",
        "ipFiltering": json!({
            "blacklist": (),
            "whitelist": ()
        }),
        "jwtVerifier": "",
        "localHost": "",
        "localScheme": "",
        "maintenanceMode": false,
        "matchingHeaders": json!({}),
        "matchingRoot": "",
        "metadata": json!({}),
        "name": "",
        "overrideHost": false,
        "privateApp": false,
        "privatePatterns": (),
        "publicPatterns": (),
        "redirectToLocal": false,
        "redirection": json!({
            "code": 0,
            "enabled": false,
            "to": ""
        }),
        "root": "",
        "secComExcludedPatterns": (),
        "secComSettings": "",
        "sendOtoroshiHeadersBack": false,
        "statsdConfig": json!({
            "datadog": false,
            "host": "",
            "port": 0
        }),
        "subdomain": "",
        "targets": (json!({})),
        "transformerRef": "",
        "userFacing": false,
        "xForwardedHeaders": false
    });

    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}}/api/services/:serviceId \
  --header 'content-type: application/json' \
  --data '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}'

echo '{
  "Canary": {
    "enabled": false,
    "root": "",
    "targets": [
      {
        "host": "",
        "scheme": ""
      }
    ],
    "traffic": 0
  },
  "additionalHeaders": {},
  "api": {
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  },
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": {
    "badResponsesFaultConfig": {
      "ratio": "",
      "responses": [
        {
          "body": "",
          "headers": {},
          "status": 0
        }
      ]
    },
    "enabled": false,
    "largeRequestFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "largeResponseFaultConfig": {
      "additionalRequestSize": 0,
      "ratio": ""
    },
    "latencyInjectionFaultConfig": {
      "from": 0,
      "ratio": "",
      "to": 0
    }
  },
  "clientConfig": {
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  },
  "clientValidatorRef": "",
  "cors": {
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  },
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": {
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  },
  "headersVerification": {},
  "healthCheck": {
    "enabled": false,
    "url": ""
  },
  "id": "",
  "ipFiltering": {
    "blacklist": [],
    "whitelist": []
  },
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": {},
  "matchingRoot": "",
  "metadata": {},
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": {
    "code": 0,
    "enabled": false,
    "to": ""
  },
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": {
    "datadog": false,
    "host": "",
    "port": 0
  },
  "subdomain": "",
  "targets": [
    {}
  ],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
}' |  \
  http PUT {{baseUrl}}/api/services/:serviceId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Canary": {\n    "enabled": false,\n    "root": "",\n    "targets": [\n      {\n        "host": "",\n        "scheme": ""\n      }\n    ],\n    "traffic": 0\n  },\n  "additionalHeaders": {},\n  "api": {\n    "exposeApi": false,\n    "openApiDescriptorUrl": ""\n  },\n  "authConfigRef": "",\n  "buildMode": false,\n  "chaosConfig": {\n    "badResponsesFaultConfig": {\n      "ratio": "",\n      "responses": [\n        {\n          "body": "",\n          "headers": {},\n          "status": 0\n        }\n      ]\n    },\n    "enabled": false,\n    "largeRequestFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "largeResponseFaultConfig": {\n      "additionalRequestSize": 0,\n      "ratio": ""\n    },\n    "latencyInjectionFaultConfig": {\n      "from": 0,\n      "ratio": "",\n      "to": 0\n    }\n  },\n  "clientConfig": {\n    "backoffFactor": 0,\n    "callTimeout": 0,\n    "globalTimeout": 0,\n    "maxErrors": 0,\n    "retries": 0,\n    "retryInitialDelay": 0,\n    "sampleInterval": 0,\n    "useCircuitBreaker": false\n  },\n  "clientValidatorRef": "",\n  "cors": {\n    "allowCredentials": false,\n    "allowHeaders": [],\n    "allowMethods": [],\n    "allowOrigin": "",\n    "enabled": false,\n    "excludedPatterns": [],\n    "exposeHeaders": [],\n    "maxAge": 0\n  },\n  "domain": "",\n  "enabled": false,\n  "enforceSecureCommunication": false,\n  "env": "",\n  "forceHttps": false,\n  "groups": [],\n  "gzip": {\n    "blackList": [],\n    "bufferSize": 0,\n    "chunkedThreshold": 0,\n    "compressionLevel": 0,\n    "enabled": false,\n    "excludedPatterns": [],\n    "whiteList": []\n  },\n  "headersVerification": {},\n  "healthCheck": {\n    "enabled": false,\n    "url": ""\n  },\n  "id": "",\n  "ipFiltering": {\n    "blacklist": [],\n    "whitelist": []\n  },\n  "jwtVerifier": "",\n  "localHost": "",\n  "localScheme": "",\n  "maintenanceMode": false,\n  "matchingHeaders": {},\n  "matchingRoot": "",\n  "metadata": {},\n  "name": "",\n  "overrideHost": false,\n  "privateApp": false,\n  "privatePatterns": [],\n  "publicPatterns": [],\n  "redirectToLocal": false,\n  "redirection": {\n    "code": 0,\n    "enabled": false,\n    "to": ""\n  },\n  "root": "",\n  "secComExcludedPatterns": [],\n  "secComSettings": "",\n  "sendOtoroshiHeadersBack": false,\n  "statsdConfig": {\n    "datadog": false,\n    "host": "",\n    "port": 0\n  },\n  "subdomain": "",\n  "targets": [\n    {}\n  ],\n  "transformerRef": "",\n  "userFacing": false,\n  "xForwardedHeaders": false\n}' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Canary": [
    "enabled": false,
    "root": "",
    "targets": [
      [
        "host": "",
        "scheme": ""
      ]
    ],
    "traffic": 0
  ],
  "additionalHeaders": [],
  "api": [
    "exposeApi": false,
    "openApiDescriptorUrl": ""
  ],
  "authConfigRef": "",
  "buildMode": false,
  "chaosConfig": [
    "badResponsesFaultConfig": [
      "ratio": "",
      "responses": [
        [
          "body": "",
          "headers": [],
          "status": 0
        ]
      ]
    ],
    "enabled": false,
    "largeRequestFaultConfig": [
      "additionalRequestSize": 0,
      "ratio": ""
    ],
    "largeResponseFaultConfig": [
      "additionalRequestSize": 0,
      "ratio": ""
    ],
    "latencyInjectionFaultConfig": [
      "from": 0,
      "ratio": "",
      "to": 0
    ]
  ],
  "clientConfig": [
    "backoffFactor": 0,
    "callTimeout": 0,
    "globalTimeout": 0,
    "maxErrors": 0,
    "retries": 0,
    "retryInitialDelay": 0,
    "sampleInterval": 0,
    "useCircuitBreaker": false
  ],
  "clientValidatorRef": "",
  "cors": [
    "allowCredentials": false,
    "allowHeaders": [],
    "allowMethods": [],
    "allowOrigin": "",
    "enabled": false,
    "excludedPatterns": [],
    "exposeHeaders": [],
    "maxAge": 0
  ],
  "domain": "",
  "enabled": false,
  "enforceSecureCommunication": false,
  "env": "",
  "forceHttps": false,
  "groups": [],
  "gzip": [
    "blackList": [],
    "bufferSize": 0,
    "chunkedThreshold": 0,
    "compressionLevel": 0,
    "enabled": false,
    "excludedPatterns": [],
    "whiteList": []
  ],
  "headersVerification": [],
  "healthCheck": [
    "enabled": false,
    "url": ""
  ],
  "id": "",
  "ipFiltering": [
    "blacklist": [],
    "whitelist": []
  ],
  "jwtVerifier": "",
  "localHost": "",
  "localScheme": "",
  "maintenanceMode": false,
  "matchingHeaders": [],
  "matchingRoot": "",
  "metadata": [],
  "name": "",
  "overrideHost": false,
  "privateApp": false,
  "privatePatterns": [],
  "publicPatterns": [],
  "redirectToLocal": false,
  "redirection": [
    "code": 0,
    "enabled": false,
    "to": ""
  ],
  "root": "",
  "secComExcludedPatterns": [],
  "secComSettings": "",
  "sendOtoroshiHeadersBack": false,
  "statsdConfig": [
    "datadog": false,
    "host": "",
    "port": 0
  ],
  "subdomain": "",
  "targets": [[]],
  "transformerRef": "",
  "userFacing": false,
  "xForwardedHeaders": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId")! 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

{
  "Canary": {
    "enabled": true,
    "root": "a string value",
    "traffic": 123123
  },
  "additionalHeaders": {
    "key": "value"
  },
  "api": {
    "exposeApi": true,
    "openApiDescriptorUrl": "http://www.google.com"
  },
  "authConfigRef": "a string value",
  "buildMode": true,
  "chaosConfig": {
    "enabled": true
  },
  "clientConfig": {
    "backoffFactor": 123123,
    "callTimeout": 123123,
    "globalTimeout": 123123,
    "maxErrors": 123123,
    "retries": 123123,
    "retryInitialDelay": 123123,
    "sampleInterval": 123123,
    "useCircuitBreaker": true
  },
  "clientValidatorRef": "a string value",
  "cors": {
    "allowCredentials": true,
    "allowOrigin": "a string value",
    "enabled": true,
    "maxAge": 123123
  },
  "domain": "a string value",
  "enabled": true,
  "enforceSecureCommunication": true,
  "env": "a string value",
  "forceHttps": true,
  "groups": [
    "a string value"
  ],
  "gzip": {
    "bufferSize": 123,
    "chunkedThreshold": 123,
    "compressionLevel": 123123,
    "enabled": true
  },
  "headersVerification": {
    "key": "value"
  },
  "healthCheck": {
    "enabled": true,
    "url": "http://www.google.com"
  },
  "id": "110e8400-e29b-11d4-a716-446655440000",
  "localHost": "a string value",
  "localScheme": "a string value",
  "maintenanceMode": true,
  "matchingHeaders": {
    "key": "value"
  },
  "matchingRoot": "a string value",
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "overrideHost": true,
  "privateApp": true,
  "privatePatterns": [
    "a string value"
  ],
  "publicPatterns": [
    "a string value"
  ],
  "redirectToLocal": true,
  "redirection": {
    "code": 123123,
    "enabled": true,
    "to": "a string value"
  },
  "root": "a string value",
  "secComExcludedPatterns": [
    "a string value"
  ],
  "sendOtoroshiHeadersBack": true,
  "statsdConfig": {
    "datadog": true,
    "host": "a string value",
    "port": 123123
  },
  "subdomain": "a string value",
  "transformerRef": "a string value",
  "userFacing": true,
  "xForwardedHeaders": true
}

PUT Update an error template to a service descriptor

{{baseUrl}}/api/services/:serviceId/template

QUERY PARAMS

serviceId

BODY json

{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/services/:serviceId/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  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/services/:serviceId/template" {:content-type :json
                                                                            :form-params {:messages {}
                                                                                          :serviceId ""
                                                                                          :template40x ""
                                                                                          :template50x ""
                                                                                          :templateBuild ""
                                                                                          :templateMaintenance ""}})

require "http/client"

url = "{{baseUrl}}/api/services/:serviceId/template"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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}}/api/services/:serviceId/template"),
    Content = new StringContent("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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}}/api/services/:serviceId/template");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/services/:serviceId/template"

	payload := strings.NewReader("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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/api/services/:serviceId/template HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 133

{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/services/:serviceId/template")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/services/:serviceId/template"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/template")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/services/:serviceId/template")
  .header("content-type", "application/json")
  .body("{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  messages: {},
  serviceId: '',
  template40x: '',
  template50x: '',
  templateBuild: '',
  templateMaintenance: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/services/:serviceId/template');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/services/:serviceId/template',
  headers: {'content-type': 'application/json'},
  data: {
    messages: {},
    serviceId: '',
    template40x: '',
    template50x: '',
    templateBuild: '',
    templateMaintenance: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/services/:serviceId/template';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/services/:serviceId/template',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "messages": {},\n  "serviceId": "",\n  "template40x": "",\n  "template50x": "",\n  "templateBuild": "",\n  "templateMaintenance": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/services/:serviceId/template")
  .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/api/services/:serviceId/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({
  messages: {},
  serviceId: '',
  template40x: '',
  template50x: '',
  templateBuild: '',
  templateMaintenance: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/services/:serviceId/template',
  headers: {'content-type': 'application/json'},
  body: {
    messages: {},
    serviceId: '',
    template40x: '',
    template50x: '',
    templateBuild: '',
    templateMaintenance: ''
  },
  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}}/api/services/:serviceId/template');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  messages: {},
  serviceId: '',
  template40x: '',
  template50x: '',
  templateBuild: '',
  templateMaintenance: ''
});

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}}/api/services/:serviceId/template',
  headers: {'content-type': 'application/json'},
  data: {
    messages: {},
    serviceId: '',
    template40x: '',
    template50x: '',
    templateBuild: '',
    templateMaintenance: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/services/:serviceId/template';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"messages":{},"serviceId":"","template40x":"","template50x":"","templateBuild":"","templateMaintenance":""}'
};

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 = @{ @"messages": @{  },
                              @"serviceId": @"",
                              @"template40x": @"",
                              @"template50x": @"",
                              @"templateBuild": @"",
                              @"templateMaintenance": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/services/:serviceId/template"]
                                                       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}}/api/services/:serviceId/template" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/services/:serviceId/template",
  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([
    'messages' => [
        
    ],
    'serviceId' => '',
    'template40x' => '',
    'template50x' => '',
    'templateBuild' => '',
    'templateMaintenance' => ''
  ]),
  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}}/api/services/:serviceId/template', [
  'body' => '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/services/:serviceId/template');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'messages' => [
    
  ],
  'serviceId' => '',
  'template40x' => '',
  'template50x' => '',
  'templateBuild' => '',
  'templateMaintenance' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'messages' => [
    
  ],
  'serviceId' => '',
  'template40x' => '',
  'template50x' => '',
  'templateBuild' => '',
  'templateMaintenance' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/services/:serviceId/template');
$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}}/api/services/:serviceId/template' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/services/:serviceId/template' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/services/:serviceId/template", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/services/:serviceId/template"

payload = {
    "messages": {},
    "serviceId": "",
    "template40x": "",
    "template50x": "",
    "templateBuild": "",
    "templateMaintenance": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/services/:serviceId/template"

payload <- "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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}}/api/services/:serviceId/template")

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  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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/api/services/:serviceId/template') do |req|
  req.body = "{\n  \"messages\": {},\n  \"serviceId\": \"\",\n  \"template40x\": \"\",\n  \"template50x\": \"\",\n  \"templateBuild\": \"\",\n  \"templateMaintenance\": \"\"\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}}/api/services/:serviceId/template";

    let payload = json!({
        "messages": json!({}),
        "serviceId": "",
        "template40x": "",
        "template50x": "",
        "templateBuild": "",
        "templateMaintenance": ""
    });

    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}}/api/services/:serviceId/template \
  --header 'content-type: application/json' \
  --data '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}'

echo '{
  "messages": {},
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
}' |  \
  http PUT {{baseUrl}}/api/services/:serviceId/template \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "messages": {},\n  "serviceId": "",\n  "template40x": "",\n  "template50x": "",\n  "templateBuild": "",\n  "templateMaintenance": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/services/:serviceId/template

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "messages": [],
  "serviceId": "",
  "template40x": "",
  "template50x": "",
  "templateBuild": "",
  "templateMaintenance": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/services/:serviceId/template")! 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

{
  "messages": {
    "key": "value"
  },
  "serviceId": "a string value",
  "template40x": "a string value",
  "template50x": "a string value",
  "templateBuild": "a string value",
  "templateMaintenance": "a string value"
}

GET Get all current Snow Monkey ourages

{{baseUrl}}/api/snowmonkey/outages

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/snowmonkey/outages");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/snowmonkey/outages")

require "http/client"

url = "{{baseUrl}}/api/snowmonkey/outages"

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}}/api/snowmonkey/outages"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/snowmonkey/outages");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/snowmonkey/outages"

	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/api/snowmonkey/outages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/snowmonkey/outages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/snowmonkey/outages"))
    .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}}/api/snowmonkey/outages")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/snowmonkey/outages")
  .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}}/api/snowmonkey/outages');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/snowmonkey/outages'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/snowmonkey/outages';
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}}/api/snowmonkey/outages',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/outages")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/snowmonkey/outages',
  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}}/api/snowmonkey/outages'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/snowmonkey/outages');

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}}/api/snowmonkey/outages'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/snowmonkey/outages';
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}}/api/snowmonkey/outages"]
                                                       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}}/api/snowmonkey/outages" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/snowmonkey/outages",
  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}}/api/snowmonkey/outages');

echo $response->getBody();

setUrl('{{baseUrl}}/api/snowmonkey/outages');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/snowmonkey/outages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/snowmonkey/outages' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/snowmonkey/outages' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/snowmonkey/outages")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/snowmonkey/outages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/snowmonkey/outages"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/snowmonkey/outages")

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/api/snowmonkey/outages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/snowmonkey/outages";

    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}}/api/snowmonkey/outages

http GET {{baseUrl}}/api/snowmonkey/outages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/snowmonkey/outages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/snowmonkey/outages")! 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

[
  {
    "descriptorId": "a string value",
    "descriptorName": "a string value",
    "duration": 123123,
    "until": "17:32:28.000"
  }
]

GET Get current Snow Monkey config

{{baseUrl}}/api/snowmonkey/config

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/snowmonkey/config");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/snowmonkey/config")

require "http/client"

url = "{{baseUrl}}/api/snowmonkey/config"

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}}/api/snowmonkey/config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/snowmonkey/config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/snowmonkey/config"

	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/api/snowmonkey/config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/snowmonkey/config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/snowmonkey/config"))
    .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}}/api/snowmonkey/config")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/snowmonkey/config")
  .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}}/api/snowmonkey/config');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/snowmonkey/config'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/snowmonkey/config';
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}}/api/snowmonkey/config',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/config")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/snowmonkey/config',
  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}}/api/snowmonkey/config'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/snowmonkey/config');

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}}/api/snowmonkey/config'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/snowmonkey/config';
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}}/api/snowmonkey/config"]
                                                       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}}/api/snowmonkey/config" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/snowmonkey/config",
  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}}/api/snowmonkey/config');

echo $response->getBody();

setUrl('{{baseUrl}}/api/snowmonkey/config');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/snowmonkey/config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/snowmonkey/config' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/snowmonkey/config' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/snowmonkey/config")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/snowmonkey/config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/snowmonkey/config"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/snowmonkey/config")

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/api/snowmonkey/config') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/snowmonkey/config";

    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}}/api/snowmonkey/config

http GET {{baseUrl}}/api/snowmonkey/config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/snowmonkey/config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/snowmonkey/config")! 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

{
  "chaosConfig": {
    "enabled": true
  },
  "dryRun": true,
  "enabled": true,
  "includeUserFacingDescriptors": true,
  "outageDurationFrom": 123123,
  "outageDurationTo": 123123,
  "startTime": "17:32:28.000",
  "stopTime": "17:32:28.000",
  "targetGroups": [
    "a string value"
  ],
  "timesPerDay": 123123
}

DELETE Reset Snow Monkey Outages for the day

{{baseUrl}}/api/snowmonkey/outages

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/snowmonkey/outages");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/snowmonkey/outages")

require "http/client"

url = "{{baseUrl}}/api/snowmonkey/outages"

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}}/api/snowmonkey/outages"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/snowmonkey/outages");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/snowmonkey/outages"

	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/api/snowmonkey/outages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/snowmonkey/outages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/snowmonkey/outages"))
    .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}}/api/snowmonkey/outages")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/snowmonkey/outages")
  .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}}/api/snowmonkey/outages');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/snowmonkey/outages'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/snowmonkey/outages';
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}}/api/snowmonkey/outages',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/outages")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/snowmonkey/outages',
  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}}/api/snowmonkey/outages'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/snowmonkey/outages');

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}}/api/snowmonkey/outages'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/snowmonkey/outages';
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}}/api/snowmonkey/outages"]
                                                       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}}/api/snowmonkey/outages" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/snowmonkey/outages",
  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}}/api/snowmonkey/outages');

echo $response->getBody();

setUrl('{{baseUrl}}/api/snowmonkey/outages');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/snowmonkey/outages');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/snowmonkey/outages' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/snowmonkey/outages' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/snowmonkey/outages")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/snowmonkey/outages"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/snowmonkey/outages"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/snowmonkey/outages")

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/api/snowmonkey/outages') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/snowmonkey/outages";

    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}}/api/snowmonkey/outages

http DELETE {{baseUrl}}/api/snowmonkey/outages

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/snowmonkey/outages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/snowmonkey/outages")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "done": true
}

POST Start the Snow Monkey

{{baseUrl}}/api/snowmonkey/_start

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/snowmonkey/_start");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/snowmonkey/_start")

require "http/client"

url = "{{baseUrl}}/api/snowmonkey/_start"

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}}/api/snowmonkey/_start"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/snowmonkey/_start");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/snowmonkey/_start"

	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/api/snowmonkey/_start HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/snowmonkey/_start")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/snowmonkey/_start"))
    .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}}/api/snowmonkey/_start")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/snowmonkey/_start")
  .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}}/api/snowmonkey/_start');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/snowmonkey/_start'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/snowmonkey/_start';
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}}/api/snowmonkey/_start',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/_start")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/snowmonkey/_start',
  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}}/api/snowmonkey/_start'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/snowmonkey/_start');

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}}/api/snowmonkey/_start'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/snowmonkey/_start';
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}}/api/snowmonkey/_start"]
                                                       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}}/api/snowmonkey/_start" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/snowmonkey/_start",
  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}}/api/snowmonkey/_start');

echo $response->getBody();

setUrl('{{baseUrl}}/api/snowmonkey/_start');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/snowmonkey/_start');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/snowmonkey/_start' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/snowmonkey/_start' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/snowmonkey/_start")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/snowmonkey/_start"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/snowmonkey/_start"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/snowmonkey/_start")

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/api/snowmonkey/_start') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/snowmonkey/_start";

    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}}/api/snowmonkey/_start

http POST {{baseUrl}}/api/snowmonkey/_start

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/snowmonkey/_start

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/snowmonkey/_start")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "done": true
}

POST Stop the Snow Monkey

{{baseUrl}}/api/snowmonkey/_stop

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/snowmonkey/_stop");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/snowmonkey/_stop")

require "http/client"

url = "{{baseUrl}}/api/snowmonkey/_stop"

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}}/api/snowmonkey/_stop"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/snowmonkey/_stop");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/snowmonkey/_stop"

	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/api/snowmonkey/_stop HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/snowmonkey/_stop")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/snowmonkey/_stop"))
    .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}}/api/snowmonkey/_stop")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/snowmonkey/_stop")
  .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}}/api/snowmonkey/_stop');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/snowmonkey/_stop'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/snowmonkey/_stop';
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}}/api/snowmonkey/_stop',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/_stop")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/snowmonkey/_stop',
  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}}/api/snowmonkey/_stop'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/snowmonkey/_stop');

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}}/api/snowmonkey/_stop'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/snowmonkey/_stop';
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}}/api/snowmonkey/_stop"]
                                                       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}}/api/snowmonkey/_stop" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/snowmonkey/_stop",
  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}}/api/snowmonkey/_stop');

echo $response->getBody();

setUrl('{{baseUrl}}/api/snowmonkey/_stop');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/snowmonkey/_stop');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/snowmonkey/_stop' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/snowmonkey/_stop' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/snowmonkey/_stop")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/snowmonkey/_stop"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/snowmonkey/_stop"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/snowmonkey/_stop")

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/api/snowmonkey/_stop') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/snowmonkey/_stop";

    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}}/api/snowmonkey/_stop

http POST {{baseUrl}}/api/snowmonkey/_stop

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/snowmonkey/_stop

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/snowmonkey/_stop")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "done": true
}

PUT Update current Snow Monkey config (PUT)

{{baseUrl}}/api/snowmonkey/config

BODY json

{
  "description": "",
  "id": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/snowmonkey/config");

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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/snowmonkey/config" {:content-type :json
                                                                 :form-params {:description ""
                                                                               :id ""
                                                                               :name ""}})

require "http/client"

url = "{{baseUrl}}/api/snowmonkey/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/snowmonkey/config"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/snowmonkey/config");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/snowmonkey/config"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"id\": \"\",\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/api/snowmonkey/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "description": "",
  "id": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/snowmonkey/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/snowmonkey/config"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"id\": \"\",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/config")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/snowmonkey/config")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  id: '',
  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}}/api/snowmonkey/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/snowmonkey/config',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/snowmonkey/config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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}}/api/snowmonkey/config',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "id": "",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/config")
  .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/api/snowmonkey/config',
  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({description: '', id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/snowmonkey/config',
  headers: {'content-type': 'application/json'},
  body: {description: '', id: '', 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}}/api/snowmonkey/config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  id: '',
  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}}/api/snowmonkey/config',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/snowmonkey/config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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 = @{ @"description": @"",
                              @"id": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/snowmonkey/config"]
                                                       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}}/api/snowmonkey/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/snowmonkey/config",
  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([
    'description' => '',
    'id' => '',
    '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}}/api/snowmonkey/config', [
  'body' => '{
  "description": "",
  "id": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/snowmonkey/config');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/snowmonkey/config');
$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}}/api/snowmonkey/config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/snowmonkey/config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/snowmonkey/config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/snowmonkey/config"

payload = {
    "description": "",
    "id": "",
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/snowmonkey/config"

payload <- "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/snowmonkey/config")

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  \"description\": \"\",\n  \"id\": \"\",\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/api/snowmonkey/config') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/snowmonkey/config";

    let payload = json!({
        "description": "",
        "id": "",
        "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}}/api/snowmonkey/config \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "id": "",
  "name": ""
}'

echo '{
  "description": "",
  "id": "",
  "name": ""
}' |  \
  http PUT {{baseUrl}}/api/snowmonkey/config \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "id": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/snowmonkey/config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "id": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/snowmonkey/config")! 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

{
  "chaosConfig": {
    "enabled": true
  },
  "dryRun": true,
  "enabled": true,
  "includeUserFacingDescriptors": true,
  "outageDurationFrom": 123123,
  "outageDurationTo": 123123,
  "startTime": "17:32:28.000",
  "stopTime": "17:32:28.000",
  "targetGroups": [
    "a string value"
  ],
  "timesPerDay": 123123
}

PATCH Update current Snow Monkey config

{{baseUrl}}/api/snowmonkey/config

BODY json

{
  "description": "",
  "id": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/snowmonkey/config");

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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/snowmonkey/config" {:content-type :json
                                                                   :form-params {:description ""
                                                                                 :id ""
                                                                                 :name ""}})

require "http/client"

url = "{{baseUrl}}/api/snowmonkey/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/snowmonkey/config"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/snowmonkey/config");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/snowmonkey/config"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/snowmonkey/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "description": "",
  "id": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/snowmonkey/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/snowmonkey/config"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"id\": \"\",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/config")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/snowmonkey/config")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  id: '',
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/snowmonkey/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/snowmonkey/config',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/snowmonkey/config';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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}}/api/snowmonkey/config',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "id": "",\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  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/snowmonkey/config")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/snowmonkey/config',
  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({description: '', id: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/snowmonkey/config',
  headers: {'content-type': 'application/json'},
  body: {description: '', id: '', 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('PATCH', '{{baseUrl}}/api/snowmonkey/config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  id: '',
  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: 'PATCH',
  url: '{{baseUrl}}/api/snowmonkey/config',
  headers: {'content-type': 'application/json'},
  data: {description: '', id: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/snowmonkey/config';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","id":"","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 = @{ @"description": @"",
                              @"id": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/snowmonkey/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/snowmonkey/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/snowmonkey/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'description' => '',
    'id' => '',
    '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('PATCH', '{{baseUrl}}/api/snowmonkey/config', [
  'body' => '{
  "description": "",
  "id": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/snowmonkey/config');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'id' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/snowmonkey/config');
$request->setRequestMethod('PATCH');
$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}}/api/snowmonkey/config' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/snowmonkey/config' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "id": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/snowmonkey/config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/snowmonkey/config"

payload = {
    "description": "",
    "id": "",
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/snowmonkey/config"

payload <- "{\n  \"description\": \"\",\n  \"id\": \"\",\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/snowmonkey/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\",\n  \"id\": \"\",\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.patch('/baseUrl/api/snowmonkey/config') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"id\": \"\",\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}}/api/snowmonkey/config";

    let payload = json!({
        "description": "",
        "id": "",
        "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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/snowmonkey/config \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "id": "",
  "name": ""
}'

echo '{
  "description": "",
  "id": "",
  "name": ""
}' |  \
  http PATCH {{baseUrl}}/api/snowmonkey/config \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "id": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/snowmonkey/config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "id": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/snowmonkey/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "chaosConfig": {
    "enabled": true
  },
  "dryRun": true,
  "enabled": true,
  "includeUserFacingDescriptors": true,
  "outageDurationFrom": 123123,
  "outageDurationTo": 123123,
  "startTime": "17:32:28.000",
  "stopTime": "17:32:28.000",
  "targetGroups": [
    "a string value"
  ],
  "timesPerDay": 123123
}

GET Get global otoroshi stats

{{baseUrl}}/api/live

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/live");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/live")

require "http/client"

url = "{{baseUrl}}/api/live"

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}}/api/live"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/live");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/live"

	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/api/live HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/live")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/live"))
    .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}}/api/live")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/live")
  .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}}/api/live');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/live'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/live';
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}}/api/live',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/live")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/live',
  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}}/api/live'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/live');

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}}/api/live'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/live';
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}}/api/live"]
                                                       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}}/api/live" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/live",
  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}}/api/live');

echo $response->getBody();

setUrl('{{baseUrl}}/api/live');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/live');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/live' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/live' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/live")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/live"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/live"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/live")

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/api/live') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/live";

    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}}/api/live

http GET {{baseUrl}}/api/live

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/live

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/live")! 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

{
  "calls": 123,
  "concurrentHandledRequests": 123,
  "dataIn": 123,
  "dataInRate": 42.2,
  "dataOut": 123,
  "dataOutRate": 42.2,
  "duration": 42.2,
  "overhead": 42.2,
  "rate": 42.2
}

GET Get live feed of otoroshi stats

{{baseUrl}}/api/live/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/live/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/live/:id")

require "http/client"

url = "{{baseUrl}}/api/live/: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}}/api/live/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/live/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/live/: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/api/live/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/live/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/live/: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}}/api/live/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/live/: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}}/api/live/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/live/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/live/: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}}/api/live/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/live/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/live/: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}}/api/live/: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}}/api/live/: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}}/api/live/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/live/: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}}/api/live/: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}}/api/live/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/live/: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}}/api/live/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/live/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/live/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/live/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/live/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/live/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/live/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/live/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/live/: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/api/live/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/live/: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}}/api/live/:id

http GET {{baseUrl}}/api/live/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/live/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/live/: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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "calls": 123,
  "concurrentHandledRequests": 123,
  "dataIn": 123,
  "dataInRate": 42.2,
  "dataOut": 123,
  "dataOutRate": 42.2,
  "duration": 42.2,
  "overhead": 42.2,
  "rate": 42.2
}

RESPONSE HEADERS

Content-Type

text/event-stream

RESPONSE BODY text

{
  "calls": 123,
  "concurrentHandledRequests": 123,
  "dataIn": 123,
  "dataInRate": 42.2,
  "dataOut": 123,
  "dataOutRate": 42.2,
  "duration": 42.2,
  "overhead": 42.2,
  "rate": 42.2
}

GET Get a template of an Otoroshi Api Key

{{baseUrl}}/new/apikey

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/new/apikey");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/new/apikey")

require "http/client"

url = "{{baseUrl}}/new/apikey"

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}}/new/apikey"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/new/apikey");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/new/apikey"

	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/new/apikey HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/new/apikey")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/new/apikey"))
    .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}}/new/apikey")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/new/apikey")
  .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}}/new/apikey');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/new/apikey'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/new/apikey';
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}}/new/apikey',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/new/apikey")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/new/apikey',
  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}}/new/apikey'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/new/apikey');

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}}/new/apikey'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/new/apikey';
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}}/new/apikey"]
                                                       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}}/new/apikey" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/new/apikey",
  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}}/new/apikey');

echo $response->getBody();

setUrl('{{baseUrl}}/new/apikey');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/new/apikey');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/new/apikey' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/new/apikey' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/new/apikey")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/new/apikey"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/new/apikey"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/new/apikey")

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/new/apikey') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/new/apikey";

    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}}/new/apikey

http GET {{baseUrl}}/new/apikey

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/new/apikey

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/new/apikey")! 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

{
  "authorizedEntities": [
    "a string value"
  ],
  "clientId": "a string value",
  "clientName": "a string value",
  "clientSecret": "a string value",
  "dailyQuota": 123,
  "enabled": true,
  "metadata": {
    "key": "value"
  },
  "monthlyQuota": 123,
  "throttlingQuota": 123
}

GET Get a template of an Otoroshi service descriptor

{{baseUrl}}/new/service

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/new/service");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/new/service")

require "http/client"

url = "{{baseUrl}}/new/service"

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}}/new/service"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/new/service");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/new/service"

	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/new/service HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/new/service")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/new/service"))
    .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}}/new/service")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/new/service")
  .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}}/new/service');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/new/service'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/new/service';
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}}/new/service',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/new/service")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/new/service',
  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}}/new/service'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/new/service');

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}}/new/service'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/new/service';
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}}/new/service"]
                                                       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}}/new/service" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/new/service",
  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}}/new/service');

echo $response->getBody();

setUrl('{{baseUrl}}/new/service');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/new/service');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/new/service' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/new/service' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/new/service")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/new/service"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/new/service"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/new/service")

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/new/service') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/new/service";

    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}}/new/service

http GET {{baseUrl}}/new/service

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/new/service

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/new/service")! 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

{
  "Canary": {
    "enabled": true,
    "root": "a string value",
    "traffic": 123123
  },
  "additionalHeaders": {
    "key": "value"
  },
  "api": {
    "exposeApi": true,
    "openApiDescriptorUrl": "http://www.google.com"
  },
  "authConfigRef": "a string value",
  "buildMode": true,
  "chaosConfig": {
    "enabled": true
  },
  "clientConfig": {
    "backoffFactor": 123123,
    "callTimeout": 123123,
    "globalTimeout": 123123,
    "maxErrors": 123123,
    "retries": 123123,
    "retryInitialDelay": 123123,
    "sampleInterval": 123123,
    "useCircuitBreaker": true
  },
  "clientValidatorRef": "a string value",
  "cors": {
    "allowCredentials": true,
    "allowOrigin": "a string value",
    "enabled": true,
    "maxAge": 123123
  },
  "domain": "a string value",
  "enabled": true,
  "enforceSecureCommunication": true,
  "env": "a string value",
  "forceHttps": true,
  "groups": [
    "a string value"
  ],
  "gzip": {
    "bufferSize": 123,
    "chunkedThreshold": 123,
    "compressionLevel": 123123,
    "enabled": true
  },
  "headersVerification": {
    "key": "value"
  },
  "healthCheck": {
    "enabled": true,
    "url": "http://www.google.com"
  },
  "id": "110e8400-e29b-11d4-a716-446655440000",
  "localHost": "a string value",
  "localScheme": "a string value",
  "maintenanceMode": true,
  "matchingHeaders": {
    "key": "value"
  },
  "matchingRoot": "a string value",
  "metadata": {
    "key": "value"
  },
  "name": "a string value",
  "overrideHost": true,
  "privateApp": true,
  "privatePatterns": [
    "a string value"
  ],
  "publicPatterns": [
    "a string value"
  ],
  "redirectToLocal": true,
  "redirection": {
    "code": 123123,
    "enabled": true,
    "to": "a string value"
  },
  "root": "a string value",
  "secComExcludedPatterns": [
    "a string value"
  ],
  "sendOtoroshiHeadersBack": true,
  "statsdConfig": {
    "datadog": true,
    "host": "a string value",
    "port": 123123
  },
  "subdomain": "a string value",
  "transformerRef": "a string value",
  "userFacing": true,
  "xForwardedHeaders": true
}

GET Get a template of an Otoroshi service group

{{baseUrl}}/new/group

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/new/group");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/new/group")

require "http/client"

url = "{{baseUrl}}/new/group"

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}}/new/group"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/new/group");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/new/group"

	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/new/group HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/new/group")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/new/group"))
    .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}}/new/group")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/new/group")
  .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}}/new/group');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/new/group'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/new/group';
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}}/new/group',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/new/group")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/new/group',
  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}}/new/group'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/new/group');

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}}/new/group'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/new/group';
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}}/new/group"]
                                                       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}}/new/group" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/new/group",
  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}}/new/group');

echo $response->getBody();

setUrl('{{baseUrl}}/new/group');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/new/group');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/new/group' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/new/group' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/new/group")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/new/group"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/new/group"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/new/group")

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/new/group') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/new/group";

    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}}/new/group

http GET {{baseUrl}}/new/group

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/new/group

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/new/group")! 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": "a string value",
  "id": "a string value",
  "name": "a string value"
}

POST Create one validation authorities

{{baseUrl}}/api/client-validators

BODY json

{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/client-validators");

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  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/client-validators" {:content-type :json
                                                                  :form-params {:alwaysValid false
                                                                                :badTtl 0
                                                                                :description ""
                                                                                :goodTtl 0
                                                                                :headers {}
                                                                                :host ""
                                                                                :id ""
                                                                                :method ""
                                                                                :name ""
                                                                                :noCache false
                                                                                :path ""
                                                                                :timeout 0
                                                                                :url ""}})

require "http/client"

url = "{{baseUrl}}/api/client-validators"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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}}/api/client-validators"),
    Content = new StringContent("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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}}/api/client-validators");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/client-validators"

	payload := strings.NewReader("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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/api/client-validators HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 214

{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/client-validators")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/client-validators"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/client-validators")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/client-validators")
  .header("content-type", "application/json")
  .body("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  alwaysValid: false,
  badTtl: 0,
  description: '',
  goodTtl: 0,
  headers: {},
  host: '',
  id: '',
  method: '',
  name: '',
  noCache: false,
  path: '',
  timeout: 0,
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/client-validators');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/client-validators',
  headers: {'content-type': 'application/json'},
  data: {
    alwaysValid: false,
    badTtl: 0,
    description: '',
    goodTtl: 0,
    headers: {},
    host: '',
    id: '',
    method: '',
    name: '',
    noCache: false,
    path: '',
    timeout: 0,
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/client-validators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alwaysValid":false,"badTtl":0,"description":"","goodTtl":0,"headers":{},"host":"","id":"","method":"","name":"","noCache":false,"path":"","timeout":0,"url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/client-validators',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alwaysValid": false,\n  "badTtl": 0,\n  "description": "",\n  "goodTtl": 0,\n  "headers": {},\n  "host": "",\n  "id": "",\n  "method": "",\n  "name": "",\n  "noCache": false,\n  "path": "",\n  "timeout": 0,\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/client-validators")
  .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/api/client-validators',
  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({
  alwaysValid: false,
  badTtl: 0,
  description: '',
  goodTtl: 0,
  headers: {},
  host: '',
  id: '',
  method: '',
  name: '',
  noCache: false,
  path: '',
  timeout: 0,
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/client-validators',
  headers: {'content-type': 'application/json'},
  body: {
    alwaysValid: false,
    badTtl: 0,
    description: '',
    goodTtl: 0,
    headers: {},
    host: '',
    id: '',
    method: '',
    name: '',
    noCache: false,
    path: '',
    timeout: 0,
    url: ''
  },
  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}}/api/client-validators');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alwaysValid: false,
  badTtl: 0,
  description: '',
  goodTtl: 0,
  headers: {},
  host: '',
  id: '',
  method: '',
  name: '',
  noCache: false,
  path: '',
  timeout: 0,
  url: ''
});

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}}/api/client-validators',
  headers: {'content-type': 'application/json'},
  data: {
    alwaysValid: false,
    badTtl: 0,
    description: '',
    goodTtl: 0,
    headers: {},
    host: '',
    id: '',
    method: '',
    name: '',
    noCache: false,
    path: '',
    timeout: 0,
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/client-validators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"alwaysValid":false,"badTtl":0,"description":"","goodTtl":0,"headers":{},"host":"","id":"","method":"","name":"","noCache":false,"path":"","timeout":0,"url":""}'
};

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 = @{ @"alwaysValid": @NO,
                              @"badTtl": @0,
                              @"description": @"",
                              @"goodTtl": @0,
                              @"headers": @{  },
                              @"host": @"",
                              @"id": @"",
                              @"method": @"",
                              @"name": @"",
                              @"noCache": @NO,
                              @"path": @"",
                              @"timeout": @0,
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/client-validators"]
                                                       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}}/api/client-validators" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/client-validators",
  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([
    'alwaysValid' => null,
    'badTtl' => 0,
    'description' => '',
    'goodTtl' => 0,
    'headers' => [
        
    ],
    'host' => '',
    'id' => '',
    'method' => '',
    'name' => '',
    'noCache' => null,
    'path' => '',
    'timeout' => 0,
    'url' => ''
  ]),
  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}}/api/client-validators', [
  'body' => '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/client-validators');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alwaysValid' => null,
  'badTtl' => 0,
  'description' => '',
  'goodTtl' => 0,
  'headers' => [
    
  ],
  'host' => '',
  'id' => '',
  'method' => '',
  'name' => '',
  'noCache' => null,
  'path' => '',
  'timeout' => 0,
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alwaysValid' => null,
  'badTtl' => 0,
  'description' => '',
  'goodTtl' => 0,
  'headers' => [
    
  ],
  'host' => '',
  'id' => '',
  'method' => '',
  'name' => '',
  'noCache' => null,
  'path' => '',
  'timeout' => 0,
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/client-validators');
$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}}/api/client-validators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/client-validators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/client-validators", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/client-validators"

payload = {
    "alwaysValid": False,
    "badTtl": 0,
    "description": "",
    "goodTtl": 0,
    "headers": {},
    "host": "",
    "id": "",
    "method": "",
    "name": "",
    "noCache": False,
    "path": "",
    "timeout": 0,
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/client-validators"

payload <- "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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}}/api/client-validators")

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  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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/api/client-validators') do |req|
  req.body = "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/client-validators";

    let payload = json!({
        "alwaysValid": false,
        "badTtl": 0,
        "description": "",
        "goodTtl": 0,
        "headers": json!({}),
        "host": "",
        "id": "",
        "method": "",
        "name": "",
        "noCache": false,
        "path": "",
        "timeout": 0,
        "url": ""
    });

    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}}/api/client-validators \
  --header 'content-type: application/json' \
  --data '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}'

echo '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}' |  \
  http POST {{baseUrl}}/api/client-validators \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "alwaysValid": false,\n  "badTtl": 0,\n  "description": "",\n  "goodTtl": 0,\n  "headers": {},\n  "host": "",\n  "id": "",\n  "method": "",\n  "name": "",\n  "noCache": false,\n  "path": "",\n  "timeout": 0,\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/client-validators

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": [],
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/client-validators")! 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

{
  "alwaysValid": true,
  "badTtl": 123,
  "description": "a string value",
  "goodTtl": 123,
  "headers": {
    "key": "value"
  },
  "host": "a string value",
  "id": "a string value",
  "method": "a string value",
  "name": "a string value",
  "noCache": true,
  "path": "a string value",
  "timeout": 123,
  "url": "a string value"
}

DELETE Delete one validation authorities by id

{{baseUrl}}/api/client-validators/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/client-validators/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/client-validators/:id")

require "http/client"

url = "{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/client-validators/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/client-validators/: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/api/client-validators/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/client-validators/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/client-validators/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/client-validators/: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/api/client-validators/: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}}/api/client-validators/: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}}/api/client-validators/: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}}/api/client-validators/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/client-validators/: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}}/api/client-validators/: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}}/api/client-validators/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/client-validators/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/client-validators/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/client-validators/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/client-validators/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/client-validators/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/client-validators/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/client-validators/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/client-validators/: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/api/client-validators/: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}}/api/client-validators/: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}}/api/client-validators/:id

http DELETE {{baseUrl}}/api/client-validators/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/client-validators/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/client-validators/: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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "deleted": true
}

GET Get all validation authoritiess

{{baseUrl}}/api/client-validators

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/client-validators");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/client-validators")

require "http/client"

url = "{{baseUrl}}/api/client-validators"

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}}/api/client-validators"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/client-validators");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/client-validators"

	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/api/client-validators HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/client-validators")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/client-validators"))
    .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}}/api/client-validators")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/client-validators")
  .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}}/api/client-validators');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/client-validators'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/client-validators';
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}}/api/client-validators',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/client-validators")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/client-validators',
  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}}/api/client-validators'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/client-validators');

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}}/api/client-validators'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/client-validators';
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}}/api/client-validators"]
                                                       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}}/api/client-validators" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/client-validators",
  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}}/api/client-validators');

echo $response->getBody();

setUrl('{{baseUrl}}/api/client-validators');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/client-validators');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/client-validators' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/client-validators' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/client-validators")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/client-validators"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/client-validators"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/client-validators")

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/api/client-validators') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/client-validators";

    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}}/api/client-validators

http GET {{baseUrl}}/api/client-validators

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/client-validators

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/client-validators")! 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

[
  {
    "alwaysValid": true,
    "badTtl": 123,
    "description": "a string value",
    "goodTtl": 123,
    "headers": {
      "key": "value"
    },
    "host": "a string value",
    "id": "a string value",
    "method": "a string value",
    "name": "a string value",
    "noCache": true,
    "path": "a string value",
    "timeout": 123,
    "url": "a string value"
  }
]

GET Get one validation authorities by id

{{baseUrl}}/api/client-validators/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/client-validators/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/client-validators/:id")

require "http/client"

url = "{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/client-validators/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/client-validators/: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/api/client-validators/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/client-validators/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/client-validators/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/client-validators/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/client-validators/: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}}/api/client-validators/: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}}/api/client-validators/: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}}/api/client-validators/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/client-validators/: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}}/api/client-validators/: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}}/api/client-validators/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/client-validators/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/client-validators/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/client-validators/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/client-validators/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/client-validators/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/client-validators/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/client-validators/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/client-validators/: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/api/client-validators/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id

http GET {{baseUrl}}/api/client-validators/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/client-validators/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/client-validators/: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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "alwaysValid": true,
  "badTtl": 123,
  "description": "a string value",
  "goodTtl": 123,
  "headers": {
    "key": "value"
  },
  "host": "a string value",
  "id": "a string value",
  "method": "a string value",
  "name": "a string value",
  "noCache": true,
  "path": "a string value",
  "timeout": 123,
  "url": "a string value"
}

PUT Update one validation authorities by id (PUT)

{{baseUrl}}/api/client-validators/:id

QUERY PARAMS

BODY json

{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/client-validators/: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  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/client-validators/:id" {:content-type :json
                                                                     :form-params {:alwaysValid false
                                                                                   :badTtl 0
                                                                                   :description ""
                                                                                   :goodTtl 0
                                                                                   :headers {}
                                                                                   :host ""
                                                                                   :id ""
                                                                                   :method ""
                                                                                   :name ""
                                                                                   :noCache false
                                                                                   :path ""
                                                                                   :timeout 0
                                                                                   :url ""}})

require "http/client"

url = "{{baseUrl}}/api/client-validators/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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}}/api/client-validators/:id"),
    Content = new StringContent("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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}}/api/client-validators/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/client-validators/:id"

	payload := strings.NewReader("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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/api/client-validators/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 214

{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/client-validators/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/client-validators/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/client-validators/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/client-validators/:id")
  .header("content-type", "application/json")
  .body("{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  alwaysValid: false,
  badTtl: 0,
  description: '',
  goodTtl: 0,
  headers: {},
  host: '',
  id: '',
  method: '',
  name: '',
  noCache: false,
  path: '',
  timeout: 0,
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/client-validators/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/client-validators/:id',
  headers: {'content-type': 'application/json'},
  data: {
    alwaysValid: false,
    badTtl: 0,
    description: '',
    goodTtl: 0,
    headers: {},
    host: '',
    id: '',
    method: '',
    name: '',
    noCache: false,
    path: '',
    timeout: 0,
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/client-validators/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alwaysValid":false,"badTtl":0,"description":"","goodTtl":0,"headers":{},"host":"","id":"","method":"","name":"","noCache":false,"path":"","timeout":0,"url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/client-validators/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "alwaysValid": false,\n  "badTtl": 0,\n  "description": "",\n  "goodTtl": 0,\n  "headers": {},\n  "host": "",\n  "id": "",\n  "method": "",\n  "name": "",\n  "noCache": false,\n  "path": "",\n  "timeout": 0,\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/client-validators/: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/api/client-validators/: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({
  alwaysValid: false,
  badTtl: 0,
  description: '',
  goodTtl: 0,
  headers: {},
  host: '',
  id: '',
  method: '',
  name: '',
  noCache: false,
  path: '',
  timeout: 0,
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/client-validators/:id',
  headers: {'content-type': 'application/json'},
  body: {
    alwaysValid: false,
    badTtl: 0,
    description: '',
    goodTtl: 0,
    headers: {},
    host: '',
    id: '',
    method: '',
    name: '',
    noCache: false,
    path: '',
    timeout: 0,
    url: ''
  },
  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}}/api/client-validators/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  alwaysValid: false,
  badTtl: 0,
  description: '',
  goodTtl: 0,
  headers: {},
  host: '',
  id: '',
  method: '',
  name: '',
  noCache: false,
  path: '',
  timeout: 0,
  url: ''
});

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}}/api/client-validators/:id',
  headers: {'content-type': 'application/json'},
  data: {
    alwaysValid: false,
    badTtl: 0,
    description: '',
    goodTtl: 0,
    headers: {},
    host: '',
    id: '',
    method: '',
    name: '',
    noCache: false,
    path: '',
    timeout: 0,
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/client-validators/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"alwaysValid":false,"badTtl":0,"description":"","goodTtl":0,"headers":{},"host":"","id":"","method":"","name":"","noCache":false,"path":"","timeout":0,"url":""}'
};

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 = @{ @"alwaysValid": @NO,
                              @"badTtl": @0,
                              @"description": @"",
                              @"goodTtl": @0,
                              @"headers": @{  },
                              @"host": @"",
                              @"id": @"",
                              @"method": @"",
                              @"name": @"",
                              @"noCache": @NO,
                              @"path": @"",
                              @"timeout": @0,
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/client-validators/: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([
    'alwaysValid' => null,
    'badTtl' => 0,
    'description' => '',
    'goodTtl' => 0,
    'headers' => [
        
    ],
    'host' => '',
    'id' => '',
    'method' => '',
    'name' => '',
    'noCache' => null,
    'path' => '',
    'timeout' => 0,
    'url' => ''
  ]),
  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}}/api/client-validators/:id', [
  'body' => '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/client-validators/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'alwaysValid' => null,
  'badTtl' => 0,
  'description' => '',
  'goodTtl' => 0,
  'headers' => [
    
  ],
  'host' => '',
  'id' => '',
  'method' => '',
  'name' => '',
  'noCache' => null,
  'path' => '',
  'timeout' => 0,
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'alwaysValid' => null,
  'badTtl' => 0,
  'description' => '',
  'goodTtl' => 0,
  'headers' => [
    
  ],
  'host' => '',
  'id' => '',
  'method' => '',
  'name' => '',
  'noCache' => null,
  'path' => '',
  'timeout' => 0,
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/client-validators/: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}}/api/client-validators/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/client-validators/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/client-validators/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/client-validators/:id"

payload = {
    "alwaysValid": False,
    "badTtl": 0,
    "description": "",
    "goodTtl": 0,
    "headers": {},
    "host": "",
    "id": "",
    "method": "",
    "name": "",
    "noCache": False,
    "path": "",
    "timeout": 0,
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/client-validators/:id"

payload <- "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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}}/api/client-validators/: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  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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/api/client-validators/:id') do |req|
  req.body = "{\n  \"alwaysValid\": false,\n  \"badTtl\": 0,\n  \"description\": \"\",\n  \"goodTtl\": 0,\n  \"headers\": {},\n  \"host\": \"\",\n  \"id\": \"\",\n  \"method\": \"\",\n  \"name\": \"\",\n  \"noCache\": false,\n  \"path\": \"\",\n  \"timeout\": 0,\n  \"url\": \"\"\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}}/api/client-validators/:id";

    let payload = json!({
        "alwaysValid": false,
        "badTtl": 0,
        "description": "",
        "goodTtl": 0,
        "headers": json!({}),
        "host": "",
        "id": "",
        "method": "",
        "name": "",
        "noCache": false,
        "path": "",
        "timeout": 0,
        "url": ""
    });

    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}}/api/client-validators/:id \
  --header 'content-type: application/json' \
  --data '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}'

echo '{
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": {},
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
}' |  \
  http PUT {{baseUrl}}/api/client-validators/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "alwaysValid": false,\n  "badTtl": 0,\n  "description": "",\n  "goodTtl": 0,\n  "headers": {},\n  "host": "",\n  "id": "",\n  "method": "",\n  "name": "",\n  "noCache": false,\n  "path": "",\n  "timeout": 0,\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/client-validators/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "alwaysValid": false,
  "badTtl": 0,
  "description": "",
  "goodTtl": 0,
  "headers": [],
  "host": "",
  "id": "",
  "method": "",
  "name": "",
  "noCache": false,
  "path": "",
  "timeout": 0,
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/client-validators/: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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "alwaysValid": true,
  "badTtl": 123,
  "description": "a string value",
  "goodTtl": 123,
  "headers": {
    "key": "value"
  },
  "host": "a string value",
  "id": "a string value",
  "method": "a string value",
  "name": "a string value",
  "noCache": true,
  "path": "a string value",
  "timeout": 123,
  "url": "a string value"
}

PATCH Update one validation authorities by id

{{baseUrl}}/api/client-validators/:id

QUERY PARAMS

BODY json

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/client-validators/: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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/client-validators/:id" {:content-type :json
                                                                       :form-params [{:op ""
                                                                                      :path ""
                                                                                      :value ""}]})

require "http/client"

url = "{{baseUrl}}/api/client-validators/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/client-validators/:id"),
    Content = new StringContent("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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}}/api/client-validators/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/client-validators/:id"

	payload := strings.NewReader("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/api/client-validators/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 57

[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/client-validators/:id")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/client-validators/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/client-validators/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/client-validators/:id")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    op: '',
    path: '',
    value: ''
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/client-validators/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/client-validators/:id',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/client-validators/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/client-validators/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\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  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/client-validators/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/client-validators/: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([{op: '', path: '', value: ''}]));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/client-validators/:id',
  headers: {'content-type': 'application/json'},
  body: [{op: '', path: '', value: ''}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/client-validators/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    op: '',
    path: '',
    value: ''
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/client-validators/:id',
  headers: {'content-type': 'application/json'},
  data: [{op: '', path: '', value: ''}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/client-validators/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '[{"op":"","path":"","value":""}]'
};

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 = @[ @{ @"op": @"", @"path": @"", @"value": @"" } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/client-validators/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/api/client-validators/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/client-validators/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'op' => '',
        'path' => '',
        'value' => ''
    ]
  ]),
  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('PATCH', '{{baseUrl}}/api/client-validators/:id', [
  'body' => '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/client-validators/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'op' => '',
    'path' => '',
    'value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/client-validators/:id');
$request->setRequestMethod('PATCH');
$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}}/api/client-validators/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/client-validators/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/api/client-validators/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/client-validators/:id"

payload = [
    {
        "op": "",
        "path": "",
        "value": ""
    }
]
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/client-validators/:id"

payload <- "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/client-validators/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\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.patch('/baseUrl/api/client-validators/:id') do |req|
  req.body = "[\n  {\n    \"op\": \"\",\n    \"path\": \"\",\n    \"value\": \"\"\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/client-validators/:id";

    let payload = (
        json!({
            "op": "",
            "path": "",
            "value": ""
        })
    );

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/client-validators/:id \
  --header 'content-type: application/json' \
  --data '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]'

echo '[
  {
    "op": "",
    "path": "",
    "value": ""
  }
]' |  \
  http PATCH {{baseUrl}}/api/client-validators/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "op": "",\n    "path": "",\n    "value": ""\n  }\n]' \
  --output-document \
  - {{baseUrl}}/api/client-validators/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "op": "",
    "path": "",
    "value": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/client-validators/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "alwaysValid": true,
  "badTtl": 123,
  "description": "a string value",
  "goodTtl": 123,
  "headers": {
    "key": "value"
  },
  "host": "a string value",
  "id": "a string value",
  "method": "a string value",
  "name": "a string value",
  "noCache": true,
  "path": "a string value",
  "timeout": 123,
  "url": "a string value"
}