CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:id/sales/activities");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/projects/:id/sales/activities")

require "http/client"

url = "{{baseUrl}}/projects/:id/sales/activities"

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

var client = new RestClient("{{baseUrl}}/projects/:id/sales/activities");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/projects/:id/sales/activities"

	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/projects/:id/sales/activities HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:id/sales/activities")
  .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}}/projects/:id/sales/activities');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/projects/:id/sales/activities'
};

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

const url = '{{baseUrl}}/projects/:id/sales/activities';
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}}/projects/:id/sales/activities',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:id/sales/activities")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:id/sales/activities');

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}}/projects/:id/sales/activities'
};

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

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

const url = '{{baseUrl}}/projects/:id/sales/activities';
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}}/projects/:id/sales/activities"]
                                                       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}}/projects/:id/sales/activities" in

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

 "{{baseUrl}}/projects/:id/sales/activities",
  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}}/projects/:id/sales/activities');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:id/sales/activities');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/projects/:id/sales/activities');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:id/sales/activities' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:id/sales/activities' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/projects/:id/sales/activities")

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

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

import requests

url = "{{baseUrl}}/projects/:id/sales/activities"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:id/sales/activities"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:id/sales/activities")

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/projects/:id/sales/activities') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/projects/:id/sales/activities

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:id/sales/activities

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:id/sales/activities");

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  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/projects/:id/sales/activities" {:content-type :json
                                                                          :form-params {:subject ""
                                                                                        :timestamp 0
                                                                                        :type ""}})

require "http/client"

url = "{{baseUrl}}/projects/:id/sales/activities"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/projects/:id/sales/activities"),
    Content = new StringContent("{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects/:id/sales/activities");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/projects/:id/sales/activities"

	payload := strings.NewReader("{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/projects/:id/sales/activities HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "subject": "",
  "timestamp": 0,
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/projects/:id/sales/activities")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/:id/sales/activities"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/projects/:id/sales/activities")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/projects/:id/sales/activities")
  .header("content-type", "application/json")
  .body("{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  subject: '',
  timestamp: 0,
  type: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/projects/:id/sales/activities');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:id/sales/activities',
  headers: {'content-type': 'application/json'},
  data: {subject: '', timestamp: 0, type: ''}
};

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

const url = '{{baseUrl}}/projects/:id/sales/activities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subject":"","timestamp":0,"type":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects/:id/sales/activities',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "subject": "",\n  "timestamp": 0,\n  "type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/projects/:id/sales/activities")
  .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/projects/:id/sales/activities',
  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({subject: '', timestamp: 0, type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:id/sales/activities',
  headers: {'content-type': 'application/json'},
  body: {subject: '', timestamp: 0, type: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/projects/:id/sales/activities');

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

req.type('json');
req.send({
  subject: '',
  timestamp: 0,
  type: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:id/sales/activities',
  headers: {'content-type': 'application/json'},
  data: {subject: '', timestamp: 0, type: ''}
};

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

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

const url = '{{baseUrl}}/projects/:id/sales/activities';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"subject":"","timestamp":0,"type":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"subject": @"",
                              @"timestamp": @0,
                              @"type": @"" };

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

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

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

 "{{baseUrl}}/projects/:id/sales/activities",
  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([
    'subject' => '',
    'timestamp' => 0,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/projects/:id/sales/activities', [
  'body' => '{
  "subject": "",
  "timestamp": 0,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:id/sales/activities');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'subject' => '',
  'timestamp' => 0,
  'type' => ''
]));

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

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

append(json_encode([
  'subject' => '',
  'timestamp' => 0,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/projects/:id/sales/activities');
$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}}/projects/:id/sales/activities' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subject": "",
  "timestamp": 0,
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:id/sales/activities' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "subject": "",
  "timestamp": 0,
  "type": ""
}'

import http.client

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

payload = "{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}"

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

conn.request("POST", "/baseUrl/projects/:id/sales/activities", payload, headers)

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

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

import requests

url = "{{baseUrl}}/projects/:id/sales/activities"

payload = {
    "subject": "",
    "timestamp": 0,
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:id/sales/activities"

payload <- "{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:id/sales/activities")

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  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/projects/:id/sales/activities') do |req|
  req.body = "{\n  \"subject\": \"\",\n  \"timestamp\": 0,\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "subject": "",
        "timestamp": 0,
        "type": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "subject": "",
  "timestamp": 0,
  "type": ""
}' |  \
  http POST {{baseUrl}}/projects/:id/sales/activities \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "subject": "",\n  "timestamp": 0,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/projects/:id/sales/activities

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "subject": "",
  "timestamp": 0,
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:projectId/activities");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/projects/:projectId/activities")

require "http/client"

url = "{{baseUrl}}/projects/:projectId/activities"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId/activities"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:projectId/activities")
  .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}}/projects/:projectId/activities');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/projects/:projectId/activities'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/activities")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:projectId/activities');

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}}/projects/:projectId/activities'
};

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

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

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

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

 "{{baseUrl}}/projects/:projectId/activities",
  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}}/projects/:projectId/activities');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId/activities');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:projectId/activities' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId/activities' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/projects/:projectId/activities")

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

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

import requests

url = "{{baseUrl}}/projects/:projectId/activities"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId/activities"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:projectId/activities")

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/projects/:projectId/activities') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/projects/:projectId/activities

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:projectId/activities

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:projectId/activities/:activityId");

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  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/projects/:projectId/activities/:activityId" {:content-type :json
                                                                                       :form-params {:comment ""
                                                                                                     :commented_at 0
                                                                                                     :id 0
                                                                                                     :links ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId/activities/:activityId"

	payload := strings.NewReader("{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\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/projects/:projectId/activities/:activityId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "comment": "",
  "commented_at": 0,
  "id": 0,
  "links": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/projects/:projectId/activities/:activityId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/projects/:projectId/activities/:activityId")
  .header("content-type", "application/json")
  .body("{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  comment: '',
  commented_at: 0,
  id: 0,
  links: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/projects/:projectId/activities/:activityId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/activities/:activityId',
  headers: {'content-type': 'application/json'},
  data: {comment: '', commented_at: 0, id: 0, links: ''}
};

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

const url = '{{baseUrl}}/projects/:projectId/activities/:activityId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"comment":"","commented_at":0,"id":0,"links":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects/:projectId/activities/:activityId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "comment": "",\n  "commented_at": 0,\n  "id": 0,\n  "links": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/activities/:activityId")
  .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/projects/:projectId/activities/:activityId',
  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({comment: '', commented_at: 0, id: 0, links: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/activities/:activityId',
  headers: {'content-type': 'application/json'},
  body: {comment: '', commented_at: 0, id: 0, links: ''},
  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}}/projects/:projectId/activities/:activityId');

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

req.type('json');
req.send({
  comment: '',
  commented_at: 0,
  id: 0,
  links: ''
});

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}}/projects/:projectId/activities/:activityId',
  headers: {'content-type': 'application/json'},
  data: {comment: '', commented_at: 0, id: 0, links: ''}
};

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

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

const url = '{{baseUrl}}/projects/:projectId/activities/:activityId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"comment":"","commented_at":0,"id":0,"links":""}'
};

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 = @{ @"comment": @"",
                              @"commented_at": @0,
                              @"id": @0,
                              @"links": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/projects/:projectId/activities/:activityId"]
                                                       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}}/projects/:projectId/activities/:activityId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\n}" in

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

 "{{baseUrl}}/projects/:projectId/activities/:activityId",
  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([
    'comment' => '',
    'commented_at' => 0,
    'id' => 0,
    'links' => ''
  ]),
  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}}/projects/:projectId/activities/:activityId', [
  'body' => '{
  "comment": "",
  "commented_at": 0,
  "id": 0,
  "links": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId/activities/:activityId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'comment' => '',
  'commented_at' => 0,
  'id' => 0,
  'links' => ''
]));

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

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

append(json_encode([
  'comment' => '',
  'commented_at' => 0,
  'id' => 0,
  'links' => ''
]));
$request->setRequestUrl('{{baseUrl}}/projects/:projectId/activities/:activityId');
$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}}/projects/:projectId/activities/:activityId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "comment": "",
  "commented_at": 0,
  "id": 0,
  "links": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId/activities/:activityId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "comment": "",
  "commented_at": 0,
  "id": 0,
  "links": ""
}'

import http.client

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

payload = "{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\n}"

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

conn.request("POST", "/baseUrl/projects/:projectId/activities/:activityId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/projects/:projectId/activities/:activityId"

payload = {
    "comment": "",
    "commented_at": 0,
    "id": 0,
    "links": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId/activities/:activityId"

payload <- "{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\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}}/projects/:projectId/activities/:activityId")

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  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\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/projects/:projectId/activities/:activityId') do |req|
  req.body = "{\n  \"comment\": \"\",\n  \"commented_at\": 0,\n  \"id\": 0,\n  \"links\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "comment": "",
        "commented_at": 0,
        "id": 0,
        "links": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "comment": "",
  "commented_at": 0,
  "id": 0,
  "links": ""
}' |  \
  http POST {{baseUrl}}/projects/:projectId/activities/:activityId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "comment": "",\n  "commented_at": 0,\n  "id": 0,\n  "links": ""\n}' \
  --output-document \
  - {{baseUrl}}/projects/:projectId/activities/:activityId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "comment": "",
  "commented_at": 0,
  "id": 0,
  "links": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:projectId/activities/:activityId/comments");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/projects/:projectId/activities/:activityId/comments")

require "http/client"

url = "{{baseUrl}}/projects/:projectId/activities/:activityId/comments"

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

var client = new RestClient("{{baseUrl}}/projects/:projectId/activities/:activityId/comments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId/activities/:activityId/comments"

	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/projects/:projectId/activities/:activityId/comments HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/:projectId/activities/:activityId/comments"))
    .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}}/projects/:projectId/activities/:activityId/comments")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:projectId/activities/:activityId/comments")
  .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}}/projects/:projectId/activities/:activityId/comments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/projects/:projectId/activities/:activityId/comments'
};

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

const url = '{{baseUrl}}/projects/:projectId/activities/:activityId/comments';
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}}/projects/:projectId/activities/:activityId/comments',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/activities/:activityId/comments")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:projectId/activities/:activityId/comments');

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}}/projects/:projectId/activities/:activityId/comments'
};

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

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

const url = '{{baseUrl}}/projects/:projectId/activities/:activityId/comments';
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}}/projects/:projectId/activities/:activityId/comments"]
                                                       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}}/projects/:projectId/activities/:activityId/comments" in

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

 "{{baseUrl}}/projects/:projectId/activities/:activityId/comments",
  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}}/projects/:projectId/activities/:activityId/comments');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId/activities/:activityId/comments');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/projects/:projectId/activities/:activityId/comments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:projectId/activities/:activityId/comments' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId/activities/:activityId/comments' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/projects/:projectId/activities/:activityId/comments")

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

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

import requests

url = "{{baseUrl}}/projects/:projectId/activities/:activityId/comments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId/activities/:activityId/comments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:projectId/activities/:activityId/comments")

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/projects/:projectId/activities/:activityId/comments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/projects/:projectId/activities/:activityId/comments";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/projects/:projectId/activities/:activityId/comments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:projectId/activities/:activityId/comments

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:projectId/comments");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/projects/:projectId/comments")

require "http/client"

url = "{{baseUrl}}/projects/:projectId/comments"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId/comments"

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

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:projectId/comments")
  .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}}/projects/:projectId/comments');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/projects/:projectId/comments'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/comments")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:projectId/comments');

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}}/projects/:projectId/comments'};

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

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

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

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

 "{{baseUrl}}/projects/:projectId/comments",
  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}}/projects/:projectId/comments');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId/comments');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:projectId/comments' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId/comments' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/projects/:projectId/comments")

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

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

import requests

url = "{{baseUrl}}/projects/:projectId/comments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId/comments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:projectId/comments")

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/projects/:projectId/comments') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/projects/:projectId/comments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:projectId/comments

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/projects/:projectId/activities/:activityId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/projects/:projectId/activities/:activityId")

require "http/client"

url = "{{baseUrl}}/projects/:projectId/activities/:activityId"

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

var client = new RestClient("{{baseUrl}}/projects/:projectId/activities/:activityId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId/activities/:activityId"

	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/projects/:projectId/activities/:activityId HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:projectId/activities/:activityId")
  .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}}/projects/:projectId/activities/:activityId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/projects/:projectId/activities/:activityId'
};

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

const url = '{{baseUrl}}/projects/:projectId/activities/:activityId';
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}}/projects/:projectId/activities/:activityId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/activities/:activityId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:projectId/activities/:activityId');

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}}/projects/:projectId/activities/:activityId'
};

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

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

const url = '{{baseUrl}}/projects/:projectId/activities/:activityId';
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}}/projects/:projectId/activities/:activityId"]
                                                       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}}/projects/:projectId/activities/:activityId" in

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

 "{{baseUrl}}/projects/:projectId/activities/:activityId",
  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}}/projects/:projectId/activities/:activityId');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId/activities/:activityId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/projects/:projectId/activities/:activityId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:projectId/activities/:activityId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId/activities/:activityId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/projects/:projectId/activities/:activityId")

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

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

import requests

url = "{{baseUrl}}/projects/:projectId/activities/:activityId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId/activities/:activityId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:projectId/activities/:activityId")

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/projects/:projectId/activities/:activityId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/projects/:projectId/activities/:activityId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:projectId/activities/:activityId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/async/download?async_request_key=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/async/download" {:query-params {:async_request_key ""}})

require "http/client"

url = "{{baseUrl}}/async/download?async_request_key="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/async/download?async_request_key="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/async/download?async_request_key=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/async/download?async_request_key="

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

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

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

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

}

GET /baseUrl/async/download?async_request_key= HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/async/download?async_request_key="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/async/download?async_request_key=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/async/download?async_request_key=")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/async/download?async_request_key=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/async/download',
  params: {async_request_key: ''}
};

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

const url = '{{baseUrl}}/async/download?async_request_key=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/async/download?async_request_key=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/async/download?async_request_key=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/async/download?async_request_key=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/async/download',
  qs: {async_request_key: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.query({
  async_request_key: ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/async/download',
  params: {async_request_key: ''}
};

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

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

const url = '{{baseUrl}}/async/download?async_request_key=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/async/download?async_request_key="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/async/download?async_request_key=" in

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

 "{{baseUrl}}/async/download?async_request_key=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/async/download?async_request_key=');

echo $response->getBody();

setUrl('{{baseUrl}}/async/download');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'async_request_key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/async/download');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'async_request_key' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/async/download?async_request_key=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/async/download?async_request_key=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/async/download?async_request_key=")

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

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

import requests

url = "{{baseUrl}}/async/download"

querystring = {"async_request_key":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/async/download"

queryString <- list(async_request_key = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/async/download?async_request_key=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/async/download') do |req|
  req.params['async_request_key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("async_request_key", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/async/download?async_request_key='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/async/download?async_request_key='

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/token")

require "http/client"

url = "{{baseUrl}}/token"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/token")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/token');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/token'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/token'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/token');

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

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

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

const options = {method: 'POST', url: '{{baseUrl}}/token'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("POST", "/baseUrl/token")

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

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

import requests

url = "{{baseUrl}}/token"

response = requests.post(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/token

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/blogs")

require "http/client"

url = "{{baseUrl}}/blogs"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/blogs"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/blogs

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/commissions" {:content-type :json
                                                        :form-params {:budget_code ""
                                                                      :date_from ""
                                                                      :date_to ""
                                                                      :source_languages []
                                                                      :target_languages []
                                                                      :users []}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\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/commissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 126

{
  "budget_code": "",
  "date_from": "",
  "date_to": "",
  "source_languages": [],
  "target_languages": [],
  "users": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/commissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/commissions")
  .header("content-type", "application/json")
  .body("{\n  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\n}")
  .asString();

const data = JSON.stringify({
  budget_code: '',
  date_from: '',
  date_to: '',
  source_languages: [],
  target_languages: [],
  users: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/commissions',
  headers: {'content-type': 'application/json'},
  data: {
    budget_code: '',
    date_from: '',
    date_to: '',
    source_languages: [],
    target_languages: [],
    users: []
  }
};

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

const url = '{{baseUrl}}/commissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"budget_code":"","date_from":"","date_to":"","source_languages":[],"target_languages":[],"users":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/commissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "budget_code": "",\n  "date_from": "",\n  "date_to": "",\n  "source_languages": [],\n  "target_languages": [],\n  "users": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/commissions")
  .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/commissions',
  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({
  budget_code: '',
  date_from: '',
  date_to: '',
  source_languages: [],
  target_languages: [],
  users: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/commissions',
  headers: {'content-type': 'application/json'},
  body: {
    budget_code: '',
    date_from: '',
    date_to: '',
    source_languages: [],
    target_languages: [],
    users: []
  },
  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}}/commissions');

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

req.type('json');
req.send({
  budget_code: '',
  date_from: '',
  date_to: '',
  source_languages: [],
  target_languages: [],
  users: []
});

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}}/commissions',
  headers: {'content-type': 'application/json'},
  data: {
    budget_code: '',
    date_from: '',
    date_to: '',
    source_languages: [],
    target_languages: [],
    users: []
  }
};

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

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

const url = '{{baseUrl}}/commissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"budget_code":"","date_from":"","date_to":"","source_languages":[],"target_languages":[],"users":[]}'
};

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 = @{ @"budget_code": @"",
                              @"date_from": @"",
                              @"date_to": @"",
                              @"source_languages": @[  ],
                              @"target_languages": @[  ],
                              @"users": @[  ] };

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

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

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

 "{{baseUrl}}/commissions",
  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([
    'budget_code' => '',
    'date_from' => '',
    'date_to' => '',
    'source_languages' => [
        
    ],
    'target_languages' => [
        
    ],
    'users' => [
        
    ]
  ]),
  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}}/commissions', [
  'body' => '{
  "budget_code": "",
  "date_from": "",
  "date_to": "",
  "source_languages": [],
  "target_languages": [],
  "users": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'budget_code' => '',
  'date_from' => '',
  'date_to' => '',
  'source_languages' => [
    
  ],
  'target_languages' => [
    
  ],
  'users' => [
    
  ]
]));

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

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

append(json_encode([
  'budget_code' => '',
  'date_from' => '',
  'date_to' => '',
  'source_languages' => [
    
  ],
  'target_languages' => [
    
  ],
  'users' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/commissions');
$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}}/commissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "budget_code": "",
  "date_from": "",
  "date_to": "",
  "source_languages": [],
  "target_languages": [],
  "users": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/commissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "budget_code": "",
  "date_from": "",
  "date_to": "",
  "source_languages": [],
  "target_languages": [],
  "users": []
}'

import http.client

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

payload = "{\n  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/commissions"

payload = {
    "budget_code": "",
    "date_from": "",
    "date_to": "",
    "source_languages": [],
    "target_languages": [],
    "users": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\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}}/commissions")

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  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\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/commissions') do |req|
  req.body = "{\n  \"budget_code\": \"\",\n  \"date_from\": \"\",\n  \"date_to\": \"\",\n  \"source_languages\": [],\n  \"target_languages\": [],\n  \"users\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "budget_code": "",
        "date_from": "",
        "date_to": "",
        "source_languages": (),
        "target_languages": (),
        "users": ()
    });

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

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

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

    dbg!(results);
}

echo '{
  "budget_code": "",
  "date_from": "",
  "date_to": "",
  "source_languages": [],
  "target_languages": [],
  "users": []
}' |  \
  http POST {{baseUrl}}/commissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "budget_code": "",\n  "date_from": "",\n  "date_to": "",\n  "source_languages": [],\n  "target_languages": [],\n  "users": []\n}' \
  --output-document \
  - {{baseUrl}}/commissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "budget_code": "",
  "date_from": "",
  "date_to": "",
  "source_languages": [],
  "target_languages": [],
  "users": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/commissions")

require "http/client"

url = "{{baseUrl}}/commissions"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/commissions"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/commissions

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/documents");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:projectId/documents" {:content-type :json
                                                                                     :form-params {:document {:data ""
                                                                                                              :name ""}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/documents"

	payload := strings.NewReader("{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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/continuous_projects/:projectId/documents HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "document": {
    "data": "",
    "name": ""
  }
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:projectId/documents")
  .header("content-type", "application/json")
  .body("{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  document: {
    data: '',
    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}}/continuous_projects/:projectId/documents');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents',
  headers: {'content-type': 'application/json'},
  data: {document: {data: '', name: ''}}
};

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

const url = '{{baseUrl}}/continuous_projects/:projectId/documents';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"document":{"data":"","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}}/continuous_projects/:projectId/documents',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "document": {\n    "data": "",\n    "name": ""\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  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/documents")
  .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/continuous_projects/:projectId/documents',
  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({document: {data: '', name: ''}}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  document: {
    data: '',
    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}}/continuous_projects/:projectId/documents',
  headers: {'content-type': 'application/json'},
  data: {document: {data: '', name: ''}}
};

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

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

const url = '{{baseUrl}}/continuous_projects/:projectId/documents';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"document":{"data":"","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 = @{ @"document": @{ @"data": @"", @"name": @"" } };

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

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

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

 "{{baseUrl}}/continuous_projects/:projectId/documents",
  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([
    'document' => [
        'data' => '',
        '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}}/continuous_projects/:projectId/documents', [
  'body' => '{
  "document": {
    "data": "",
    "name": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/documents');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'document' => [
    'data' => '',
    'name' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/documents');
$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}}/continuous_projects/:projectId/documents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "document": {
    "data": "",
    "name": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/documents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "document": {
    "data": "",
    "name": ""
  }
}'

import http.client

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

payload = "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/continuous_projects/:projectId/documents", payload, headers)

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/documents"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/documents"

payload <- "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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}}/continuous_projects/:projectId/documents")

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  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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/continuous_projects/:projectId/documents') do |req|
  req.body = "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"document": json!({
            "data": "",
            "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);
}

echo '{
  "document": {
    "data": "",
    "name": ""
  }
}' |  \
  http POST {{baseUrl}}/continuous_projects/:projectId/documents \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "document": {\n    "data": "",\n    "name": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/documents

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete"

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

var client = new RestClient("{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete"

	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/continuous_projects/:id/documents/:documentId/complete HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete"))
    .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}}/continuous_projects/:id/documents/:documentId/complete")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete")
  .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}}/continuous_projects/:id/documents/:documentId/complete');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete'
};

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

const url = '{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete';
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}}/continuous_projects/:id/documents/:documentId/complete',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:id/documents/:documentId/complete',
  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}}/continuous_projects/:id/documents/:documentId/complete'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete');

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}}/continuous_projects/:id/documents/:documentId/complete'
};

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

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

const url = '{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete';
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}}/continuous_projects/:id/documents/:documentId/complete"]
                                                       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}}/continuous_projects/:id/documents/:documentId/complete" in

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

 "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete",
  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}}/continuous_projects/:id/documents/:documentId/complete');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/continuous_projects/:id/documents/:documentId/complete")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete")

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/continuous_projects/:id/documents/:documentId/complete') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/continuous_projects/:id/documents/:documentId/complete

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/documents/:documentId/complete

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/documents/:documentId/complete")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete"

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

var client = new RestClient("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete"

	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/continuous_projects/:id/languages/:targetLanguage/complete HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete"))
    .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}}/continuous_projects/:id/languages/:targetLanguage/complete")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete")
  .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}}/continuous_projects/:id/languages/:targetLanguage/complete');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete'
};

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

const url = '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete';
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}}/continuous_projects/:id/languages/:targetLanguage/complete',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:id/languages/:targetLanguage/complete',
  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}}/continuous_projects/:id/languages/:targetLanguage/complete'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete');

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}}/continuous_projects/:id/languages/:targetLanguage/complete'
};

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

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

const url = '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete';
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}}/continuous_projects/:id/languages/:targetLanguage/complete"]
                                                       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}}/continuous_projects/:id/languages/:targetLanguage/complete" in

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

 "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete",
  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}}/continuous_projects/:id/languages/:targetLanguage/complete');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/continuous_projects/:id/languages/:targetLanguage/complete")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete")

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/continuous_projects/:id/languages/:targetLanguage/complete') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/complete")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/complete");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:id/complete")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/complete"

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

var client = new RestClient("{{baseUrl}}/continuous_projects/:id/complete");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/complete"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/complete"))
    .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}}/continuous_projects/:id/complete")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/complete")
  .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}}/continuous_projects/:id/complete');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/complete'
};

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

const url = '{{baseUrl}}/continuous_projects/:id/complete';
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}}/continuous_projects/:id/complete',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/complete")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/continuous_projects/:id/complete');

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}}/continuous_projects/:id/complete'
};

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

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

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

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

 "{{baseUrl}}/continuous_projects/:id/complete",
  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}}/continuous_projects/:id/complete');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/complete');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/continuous_projects/:id/complete');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/complete' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/complete' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/continuous_projects/:id/complete")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id/complete"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/complete"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/complete")

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/continuous_projects/:id/complete') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/continuous_projects/:id/complete

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/complete

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects" {:content-type :json
                                                                :form-params {:analytics_enabled false
                                                                              :auto_start_postedit false
                                                                              :created_at ""
                                                                              :id 0
                                                                              :is_enabled false
                                                                              :last_activity_at ""
                                                                              :links ""
                                                                              :mt_enabled false
                                                                              :mt_engine ""
                                                                              :name ""
                                                                              :postedit_enabled false
                                                                              :source_language ""
                                                                              :status ""
                                                                              :subscription {:downgrade []
                                                                                             :payment_method 0
                                                                                             :period_end ""
                                                                                             :plan_id ""
                                                                                             :plan_name ""
                                                                                             :price ""
                                                                                             :products []
                                                                                             :schedule_name ""
                                                                                             :schedule_start ""
                                                                                             :subscription_id ""
                                                                                             :upgrade []
                                                                                             :withTrial ""}
                                                                              :target_languages []
                                                                              :type ""
                                                                              :word_count 0}})

require "http/client"

url = "{{baseUrl}}/continuous_projects"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 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}}/continuous_projects"),
    Content = new StringContent("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 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}}/continuous_projects");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 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/continuous_projects HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 631

{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "created_at": "",
  "id": 0,
  "is_enabled": false,
  "last_activity_at": "",
  "links": "",
  "mt_enabled": false,
  "mt_engine": "",
  "name": "",
  "postedit_enabled": false,
  "source_language": "",
  "status": "",
  "subscription": {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
  },
  "target_languages": [],
  "type": "",
  "word_count": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects")
  .header("content-type", "application/json")
  .body("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}")
  .asString();

const data = JSON.stringify({
  analytics_enabled: false,
  auto_start_postedit: false,
  created_at: '',
  id: 0,
  is_enabled: false,
  last_activity_at: '',
  links: '',
  mt_enabled: false,
  mt_engine: '',
  name: '',
  postedit_enabled: false,
  source_language: '',
  status: '',
  subscription: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  },
  target_languages: [],
  type: '',
  word_count: 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}}/continuous_projects');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects',
  headers: {'content-type': 'application/json'},
  data: {
    analytics_enabled: false,
    auto_start_postedit: false,
    created_at: '',
    id: 0,
    is_enabled: false,
    last_activity_at: '',
    links: '',
    mt_enabled: false,
    mt_engine: '',
    name: '',
    postedit_enabled: false,
    source_language: '',
    status: '',
    subscription: {
      downgrade: [],
      payment_method: 0,
      period_end: '',
      plan_id: '',
      plan_name: '',
      price: '',
      products: [],
      schedule_name: '',
      schedule_start: '',
      subscription_id: '',
      upgrade: [],
      withTrial: ''
    },
    target_languages: [],
    type: '',
    word_count: 0
  }
};

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

const url = '{{baseUrl}}/continuous_projects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"analytics_enabled":false,"auto_start_postedit":false,"created_at":"","id":0,"is_enabled":false,"last_activity_at":"","links":"","mt_enabled":false,"mt_engine":"","name":"","postedit_enabled":false,"source_language":"","status":"","subscription":{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""},"target_languages":[],"type":"","word_count":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}}/continuous_projects',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "analytics_enabled": false,\n  "auto_start_postedit": false,\n  "created_at": "",\n  "id": 0,\n  "is_enabled": false,\n  "last_activity_at": "",\n  "links": "",\n  "mt_enabled": false,\n  "mt_engine": "",\n  "name": "",\n  "postedit_enabled": false,\n  "source_language": "",\n  "status": "",\n  "subscription": {\n    "downgrade": [],\n    "payment_method": 0,\n    "period_end": "",\n    "plan_id": "",\n    "plan_name": "",\n    "price": "",\n    "products": [],\n    "schedule_name": "",\n    "schedule_start": "",\n    "subscription_id": "",\n    "upgrade": [],\n    "withTrial": ""\n  },\n  "target_languages": [],\n  "type": "",\n  "word_count": 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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects")
  .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/continuous_projects',
  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({
  analytics_enabled: false,
  auto_start_postedit: false,
  created_at: '',
  id: 0,
  is_enabled: false,
  last_activity_at: '',
  links: '',
  mt_enabled: false,
  mt_engine: '',
  name: '',
  postedit_enabled: false,
  source_language: '',
  status: '',
  subscription: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  },
  target_languages: [],
  type: '',
  word_count: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects',
  headers: {'content-type': 'application/json'},
  body: {
    analytics_enabled: false,
    auto_start_postedit: false,
    created_at: '',
    id: 0,
    is_enabled: false,
    last_activity_at: '',
    links: '',
    mt_enabled: false,
    mt_engine: '',
    name: '',
    postedit_enabled: false,
    source_language: '',
    status: '',
    subscription: {
      downgrade: [],
      payment_method: 0,
      period_end: '',
      plan_id: '',
      plan_name: '',
      price: '',
      products: [],
      schedule_name: '',
      schedule_start: '',
      subscription_id: '',
      upgrade: [],
      withTrial: ''
    },
    target_languages: [],
    type: '',
    word_count: 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}}/continuous_projects');

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

req.type('json');
req.send({
  analytics_enabled: false,
  auto_start_postedit: false,
  created_at: '',
  id: 0,
  is_enabled: false,
  last_activity_at: '',
  links: '',
  mt_enabled: false,
  mt_engine: '',
  name: '',
  postedit_enabled: false,
  source_language: '',
  status: '',
  subscription: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  },
  target_languages: [],
  type: '',
  word_count: 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}}/continuous_projects',
  headers: {'content-type': 'application/json'},
  data: {
    analytics_enabled: false,
    auto_start_postedit: false,
    created_at: '',
    id: 0,
    is_enabled: false,
    last_activity_at: '',
    links: '',
    mt_enabled: false,
    mt_engine: '',
    name: '',
    postedit_enabled: false,
    source_language: '',
    status: '',
    subscription: {
      downgrade: [],
      payment_method: 0,
      period_end: '',
      plan_id: '',
      plan_name: '',
      price: '',
      products: [],
      schedule_name: '',
      schedule_start: '',
      subscription_id: '',
      upgrade: [],
      withTrial: ''
    },
    target_languages: [],
    type: '',
    word_count: 0
  }
};

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

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

const url = '{{baseUrl}}/continuous_projects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"analytics_enabled":false,"auto_start_postedit":false,"created_at":"","id":0,"is_enabled":false,"last_activity_at":"","links":"","mt_enabled":false,"mt_engine":"","name":"","postedit_enabled":false,"source_language":"","status":"","subscription":{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""},"target_languages":[],"type":"","word_count":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 = @{ @"analytics_enabled": @NO,
                              @"auto_start_postedit": @NO,
                              @"created_at": @"",
                              @"id": @0,
                              @"is_enabled": @NO,
                              @"last_activity_at": @"",
                              @"links": @"",
                              @"mt_enabled": @NO,
                              @"mt_engine": @"",
                              @"name": @"",
                              @"postedit_enabled": @NO,
                              @"source_language": @"",
                              @"status": @"",
                              @"subscription": @{ @"downgrade": @[  ], @"payment_method": @0, @"period_end": @"", @"plan_id": @"", @"plan_name": @"", @"price": @"", @"products": @[  ], @"schedule_name": @"", @"schedule_start": @"", @"subscription_id": @"", @"upgrade": @[  ], @"withTrial": @"" },
                              @"target_languages": @[  ],
                              @"type": @"",
                              @"word_count": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects"]
                                                       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}}/continuous_projects" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}" in

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

 "{{baseUrl}}/continuous_projects",
  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([
    'analytics_enabled' => null,
    'auto_start_postedit' => null,
    'created_at' => '',
    'id' => 0,
    'is_enabled' => null,
    'last_activity_at' => '',
    'links' => '',
    'mt_enabled' => null,
    'mt_engine' => '',
    'name' => '',
    'postedit_enabled' => null,
    'source_language' => '',
    'status' => '',
    'subscription' => [
        'downgrade' => [
                
        ],
        'payment_method' => 0,
        'period_end' => '',
        'plan_id' => '',
        'plan_name' => '',
        'price' => '',
        'products' => [
                
        ],
        'schedule_name' => '',
        'schedule_start' => '',
        'subscription_id' => '',
        'upgrade' => [
                
        ],
        'withTrial' => ''
    ],
    'target_languages' => [
        
    ],
    'type' => '',
    'word_count' => 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}}/continuous_projects', [
  'body' => '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "created_at": "",
  "id": 0,
  "is_enabled": false,
  "last_activity_at": "",
  "links": "",
  "mt_enabled": false,
  "mt_engine": "",
  "name": "",
  "postedit_enabled": false,
  "source_language": "",
  "status": "",
  "subscription": {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
  },
  "target_languages": [],
  "type": "",
  "word_count": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'analytics_enabled' => null,
  'auto_start_postedit' => null,
  'created_at' => '',
  'id' => 0,
  'is_enabled' => null,
  'last_activity_at' => '',
  'links' => '',
  'mt_enabled' => null,
  'mt_engine' => '',
  'name' => '',
  'postedit_enabled' => null,
  'source_language' => '',
  'status' => '',
  'subscription' => [
    'downgrade' => [
        
    ],
    'payment_method' => 0,
    'period_end' => '',
    'plan_id' => '',
    'plan_name' => '',
    'price' => '',
    'products' => [
        
    ],
    'schedule_name' => '',
    'schedule_start' => '',
    'subscription_id' => '',
    'upgrade' => [
        
    ],
    'withTrial' => ''
  ],
  'target_languages' => [
    
  ],
  'type' => '',
  'word_count' => 0
]));

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

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

append(json_encode([
  'analytics_enabled' => null,
  'auto_start_postedit' => null,
  'created_at' => '',
  'id' => 0,
  'is_enabled' => null,
  'last_activity_at' => '',
  'links' => '',
  'mt_enabled' => null,
  'mt_engine' => '',
  'name' => '',
  'postedit_enabled' => null,
  'source_language' => '',
  'status' => '',
  'subscription' => [
    'downgrade' => [
        
    ],
    'payment_method' => 0,
    'period_end' => '',
    'plan_id' => '',
    'plan_name' => '',
    'price' => '',
    'products' => [
        
    ],
    'schedule_name' => '',
    'schedule_start' => '',
    'subscription_id' => '',
    'upgrade' => [
        
    ],
    'withTrial' => ''
  ],
  'target_languages' => [
    
  ],
  'type' => '',
  'word_count' => 0
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects');
$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}}/continuous_projects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "created_at": "",
  "id": 0,
  "is_enabled": false,
  "last_activity_at": "",
  "links": "",
  "mt_enabled": false,
  "mt_engine": "",
  "name": "",
  "postedit_enabled": false,
  "source_language": "",
  "status": "",
  "subscription": {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
  },
  "target_languages": [],
  "type": "",
  "word_count": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "created_at": "",
  "id": 0,
  "is_enabled": false,
  "last_activity_at": "",
  "links": "",
  "mt_enabled": false,
  "mt_engine": "",
  "name": "",
  "postedit_enabled": false,
  "source_language": "",
  "status": "",
  "subscription": {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
  },
  "target_languages": [],
  "type": "",
  "word_count": 0
}'

import http.client

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

payload = "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/continuous_projects"

payload = {
    "analytics_enabled": False,
    "auto_start_postedit": False,
    "created_at": "",
    "id": 0,
    "is_enabled": False,
    "last_activity_at": "",
    "links": "",
    "mt_enabled": False,
    "mt_engine": "",
    "name": "",
    "postedit_enabled": False,
    "source_language": "",
    "status": "",
    "subscription": {
        "downgrade": [],
        "payment_method": 0,
        "period_end": "",
        "plan_id": "",
        "plan_name": "",
        "price": "",
        "products": [],
        "schedule_name": "",
        "schedule_start": "",
        "subscription_id": "",
        "upgrade": [],
        "withTrial": ""
    },
    "target_languages": [],
    "type": "",
    "word_count": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 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}}/continuous_projects")

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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 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/continuous_projects') do |req|
  req.body = "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"created_at\": \"\",\n  \"id\": 0,\n  \"is_enabled\": false,\n  \"last_activity_at\": \"\",\n  \"links\": \"\",\n  \"mt_enabled\": false,\n  \"mt_engine\": \"\",\n  \"name\": \"\",\n  \"postedit_enabled\": false,\n  \"source_language\": \"\",\n  \"status\": \"\",\n  \"subscription\": {\n    \"downgrade\": [],\n    \"payment_method\": 0,\n    \"period_end\": \"\",\n    \"plan_id\": \"\",\n    \"plan_name\": \"\",\n    \"price\": \"\",\n    \"products\": [],\n    \"schedule_name\": \"\",\n    \"schedule_start\": \"\",\n    \"subscription_id\": \"\",\n    \"upgrade\": [],\n    \"withTrial\": \"\"\n  },\n  \"target_languages\": [],\n  \"type\": \"\",\n  \"word_count\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "analytics_enabled": false,
        "auto_start_postedit": false,
        "created_at": "",
        "id": 0,
        "is_enabled": false,
        "last_activity_at": "",
        "links": "",
        "mt_enabled": false,
        "mt_engine": "",
        "name": "",
        "postedit_enabled": false,
        "source_language": "",
        "status": "",
        "subscription": json!({
            "downgrade": (),
            "payment_method": 0,
            "period_end": "",
            "plan_id": "",
            "plan_name": "",
            "price": "",
            "products": (),
            "schedule_name": "",
            "schedule_start": "",
            "subscription_id": "",
            "upgrade": (),
            "withTrial": ""
        }),
        "target_languages": (),
        "type": "",
        "word_count": 0
    });

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

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

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

    dbg!(results);
}

echo '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "created_at": "",
  "id": 0,
  "is_enabled": false,
  "last_activity_at": "",
  "links": "",
  "mt_enabled": false,
  "mt_engine": "",
  "name": "",
  "postedit_enabled": false,
  "source_language": "",
  "status": "",
  "subscription": {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
  },
  "target_languages": [],
  "type": "",
  "word_count": 0
}' |  \
  http POST {{baseUrl}}/continuous_projects \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "analytics_enabled": false,\n  "auto_start_postedit": false,\n  "created_at": "",\n  "id": 0,\n  "is_enabled": false,\n  "last_activity_at": "",\n  "links": "",\n  "mt_enabled": false,\n  "mt_engine": "",\n  "name": "",\n  "postedit_enabled": false,\n  "source_language": "",\n  "status": "",\n  "subscription": {\n    "downgrade": [],\n    "payment_method": 0,\n    "period_end": "",\n    "plan_id": "",\n    "plan_name": "",\n    "price": "",\n    "products": [],\n    "schedule_name": "",\n    "schedule_start": "",\n    "subscription_id": "",\n    "upgrade": [],\n    "withTrial": ""\n  },\n  "target_languages": [],\n  "type": "",\n  "word_count": 0\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "created_at": "",
  "id": 0,
  "is_enabled": false,
  "last_activity_at": "",
  "links": "",
  "mt_enabled": false,
  "mt_engine": "",
  "name": "",
  "postedit_enabled": false,
  "source_language": "",
  "status": "",
  "subscription": [
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
  ],
  "target_languages": [],
  "type": "",
  "word_count": 0
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/widgets");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:projectId/widgets" {:content-type :json
                                                                                   :form-params {:allow_hash_in_url false
                                                                                                 :allow_query_in_url false
                                                                                                 :auto_detect_source_language false
                                                                                                 :created_at ""
                                                                                                 :elements ""
                                                                                                 :follow_user false
                                                                                                 :force_cache_refresh_interval false
                                                                                                 :id 0
                                                                                                 :language_mappings ""
                                                                                                 :live false
                                                                                                 :modify_links false
                                                                                                 :name ""
                                                                                                 :optimize_per_page false
                                                                                                 :pages ""
                                                                                                 :path_regex ""
                                                                                                 :position ""
                                                                                                 :query_name ""
                                                                                                 :reboot_on_url_change false
                                                                                                 :restricted_domains ""
                                                                                                 :sections ""
                                                                                                 :test_mode false
                                                                                                 :theme ""
                                                                                                 :token ""
                                                                                                 :url_change_mode ""
                                                                                                 :url_mode ""
                                                                                                 :use_cache false
                                                                                                 :use_dummy_translations false
                                                                                                 :variables ""}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/widgets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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}}/continuous_projects/:projectId/widgets"),
    Content = new StringContent("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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}}/continuous_projects/:projectId/widgets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/widgets"

	payload := strings.NewReader("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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/continuous_projects/:projectId/widgets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 653

{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:projectId/widgets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/widgets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:projectId/widgets")
  .header("content-type", "application/json")
  .body("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  allow_hash_in_url: false,
  allow_query_in_url: false,
  auto_detect_source_language: false,
  created_at: '',
  elements: '',
  follow_user: false,
  force_cache_refresh_interval: false,
  id: 0,
  language_mappings: '',
  live: false,
  modify_links: false,
  name: '',
  optimize_per_page: false,
  pages: '',
  path_regex: '',
  position: '',
  query_name: '',
  reboot_on_url_change: false,
  restricted_domains: '',
  sections: '',
  test_mode: false,
  theme: '',
  token: '',
  url_change_mode: '',
  url_mode: '',
  use_cache: false,
  use_dummy_translations: false,
  variables: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/continuous_projects/:projectId/widgets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets',
  headers: {'content-type': 'application/json'},
  data: {
    allow_hash_in_url: false,
    allow_query_in_url: false,
    auto_detect_source_language: false,
    created_at: '',
    elements: '',
    follow_user: false,
    force_cache_refresh_interval: false,
    id: 0,
    language_mappings: '',
    live: false,
    modify_links: false,
    name: '',
    optimize_per_page: false,
    pages: '',
    path_regex: '',
    position: '',
    query_name: '',
    reboot_on_url_change: false,
    restricted_domains: '',
    sections: '',
    test_mode: false,
    theme: '',
    token: '',
    url_change_mode: '',
    url_mode: '',
    use_cache: false,
    use_dummy_translations: false,
    variables: ''
  }
};

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

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allow_hash_in_url":false,"allow_query_in_url":false,"auto_detect_source_language":false,"created_at":"","elements":"","follow_user":false,"force_cache_refresh_interval":false,"id":0,"language_mappings":"","live":false,"modify_links":false,"name":"","optimize_per_page":false,"pages":"","path_regex":"","position":"","query_name":"","reboot_on_url_change":false,"restricted_domains":"","sections":"","test_mode":false,"theme":"","token":"","url_change_mode":"","url_mode":"","use_cache":false,"use_dummy_translations":false,"variables":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "allow_hash_in_url": false,\n  "allow_query_in_url": false,\n  "auto_detect_source_language": false,\n  "created_at": "",\n  "elements": "",\n  "follow_user": false,\n  "force_cache_refresh_interval": false,\n  "id": 0,\n  "language_mappings": "",\n  "live": false,\n  "modify_links": false,\n  "name": "",\n  "optimize_per_page": false,\n  "pages": "",\n  "path_regex": "",\n  "position": "",\n  "query_name": "",\n  "reboot_on_url_change": false,\n  "restricted_domains": "",\n  "sections": "",\n  "test_mode": false,\n  "theme": "",\n  "token": "",\n  "url_change_mode": "",\n  "url_mode": "",\n  "use_cache": false,\n  "use_dummy_translations": false,\n  "variables": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets")
  .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/continuous_projects/:projectId/widgets',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  allow_hash_in_url: false,
  allow_query_in_url: false,
  auto_detect_source_language: false,
  created_at: '',
  elements: '',
  follow_user: false,
  force_cache_refresh_interval: false,
  id: 0,
  language_mappings: '',
  live: false,
  modify_links: false,
  name: '',
  optimize_per_page: false,
  pages: '',
  path_regex: '',
  position: '',
  query_name: '',
  reboot_on_url_change: false,
  restricted_domains: '',
  sections: '',
  test_mode: false,
  theme: '',
  token: '',
  url_change_mode: '',
  url_mode: '',
  use_cache: false,
  use_dummy_translations: false,
  variables: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets',
  headers: {'content-type': 'application/json'},
  body: {
    allow_hash_in_url: false,
    allow_query_in_url: false,
    auto_detect_source_language: false,
    created_at: '',
    elements: '',
    follow_user: false,
    force_cache_refresh_interval: false,
    id: 0,
    language_mappings: '',
    live: false,
    modify_links: false,
    name: '',
    optimize_per_page: false,
    pages: '',
    path_regex: '',
    position: '',
    query_name: '',
    reboot_on_url_change: false,
    restricted_domains: '',
    sections: '',
    test_mode: false,
    theme: '',
    token: '',
    url_change_mode: '',
    url_mode: '',
    use_cache: false,
    use_dummy_translations: false,
    variables: ''
  },
  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}}/continuous_projects/:projectId/widgets');

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

req.type('json');
req.send({
  allow_hash_in_url: false,
  allow_query_in_url: false,
  auto_detect_source_language: false,
  created_at: '',
  elements: '',
  follow_user: false,
  force_cache_refresh_interval: false,
  id: 0,
  language_mappings: '',
  live: false,
  modify_links: false,
  name: '',
  optimize_per_page: false,
  pages: '',
  path_regex: '',
  position: '',
  query_name: '',
  reboot_on_url_change: false,
  restricted_domains: '',
  sections: '',
  test_mode: false,
  theme: '',
  token: '',
  url_change_mode: '',
  url_mode: '',
  use_cache: false,
  use_dummy_translations: false,
  variables: ''
});

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}}/continuous_projects/:projectId/widgets',
  headers: {'content-type': 'application/json'},
  data: {
    allow_hash_in_url: false,
    allow_query_in_url: false,
    auto_detect_source_language: false,
    created_at: '',
    elements: '',
    follow_user: false,
    force_cache_refresh_interval: false,
    id: 0,
    language_mappings: '',
    live: false,
    modify_links: false,
    name: '',
    optimize_per_page: false,
    pages: '',
    path_regex: '',
    position: '',
    query_name: '',
    reboot_on_url_change: false,
    restricted_domains: '',
    sections: '',
    test_mode: false,
    theme: '',
    token: '',
    url_change_mode: '',
    url_mode: '',
    use_cache: false,
    use_dummy_translations: false,
    variables: ''
  }
};

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

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

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allow_hash_in_url":false,"allow_query_in_url":false,"auto_detect_source_language":false,"created_at":"","elements":"","follow_user":false,"force_cache_refresh_interval":false,"id":0,"language_mappings":"","live":false,"modify_links":false,"name":"","optimize_per_page":false,"pages":"","path_regex":"","position":"","query_name":"","reboot_on_url_change":false,"restricted_domains":"","sections":"","test_mode":false,"theme":"","token":"","url_change_mode":"","url_mode":"","use_cache":false,"use_dummy_translations":false,"variables":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"allow_hash_in_url": @NO,
                              @"allow_query_in_url": @NO,
                              @"auto_detect_source_language": @NO,
                              @"created_at": @"",
                              @"elements": @"",
                              @"follow_user": @NO,
                              @"force_cache_refresh_interval": @NO,
                              @"id": @0,
                              @"language_mappings": @"",
                              @"live": @NO,
                              @"modify_links": @NO,
                              @"name": @"",
                              @"optimize_per_page": @NO,
                              @"pages": @"",
                              @"path_regex": @"",
                              @"position": @"",
                              @"query_name": @"",
                              @"reboot_on_url_change": @NO,
                              @"restricted_domains": @"",
                              @"sections": @"",
                              @"test_mode": @NO,
                              @"theme": @"",
                              @"token": @"",
                              @"url_change_mode": @"",
                              @"url_mode": @"",
                              @"use_cache": @NO,
                              @"use_dummy_translations": @NO,
                              @"variables": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:projectId/widgets"]
                                                       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}}/continuous_projects/:projectId/widgets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}" in

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

 "{{baseUrl}}/continuous_projects/:projectId/widgets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'allow_hash_in_url' => null,
    'allow_query_in_url' => null,
    'auto_detect_source_language' => null,
    'created_at' => '',
    'elements' => '',
    'follow_user' => null,
    'force_cache_refresh_interval' => null,
    'id' => 0,
    'language_mappings' => '',
    'live' => null,
    'modify_links' => null,
    'name' => '',
    'optimize_per_page' => null,
    'pages' => '',
    'path_regex' => '',
    'position' => '',
    'query_name' => '',
    'reboot_on_url_change' => null,
    'restricted_domains' => '',
    'sections' => '',
    'test_mode' => null,
    'theme' => '',
    'token' => '',
    'url_change_mode' => '',
    'url_mode' => '',
    'use_cache' => null,
    'use_dummy_translations' => null,
    'variables' => ''
  ]),
  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}}/continuous_projects/:projectId/widgets', [
  'body' => '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/widgets');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allow_hash_in_url' => null,
  'allow_query_in_url' => null,
  'auto_detect_source_language' => null,
  'created_at' => '',
  'elements' => '',
  'follow_user' => null,
  'force_cache_refresh_interval' => null,
  'id' => 0,
  'language_mappings' => '',
  'live' => null,
  'modify_links' => null,
  'name' => '',
  'optimize_per_page' => null,
  'pages' => '',
  'path_regex' => '',
  'position' => '',
  'query_name' => '',
  'reboot_on_url_change' => null,
  'restricted_domains' => '',
  'sections' => '',
  'test_mode' => null,
  'theme' => '',
  'token' => '',
  'url_change_mode' => '',
  'url_mode' => '',
  'use_cache' => null,
  'use_dummy_translations' => null,
  'variables' => ''
]));

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

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

append(json_encode([
  'allow_hash_in_url' => null,
  'allow_query_in_url' => null,
  'auto_detect_source_language' => null,
  'created_at' => '',
  'elements' => '',
  'follow_user' => null,
  'force_cache_refresh_interval' => null,
  'id' => 0,
  'language_mappings' => '',
  'live' => null,
  'modify_links' => null,
  'name' => '',
  'optimize_per_page' => null,
  'pages' => '',
  'path_regex' => '',
  'position' => '',
  'query_name' => '',
  'reboot_on_url_change' => null,
  'restricted_domains' => '',
  'sections' => '',
  'test_mode' => null,
  'theme' => '',
  'token' => '',
  'url_change_mode' => '',
  'url_mode' => '',
  'use_cache' => null,
  'use_dummy_translations' => null,
  'variables' => ''
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/widgets');
$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}}/continuous_projects/:projectId/widgets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}'

import http.client

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

payload = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}"

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

conn.request("POST", "/baseUrl/continuous_projects/:projectId/widgets", payload, headers)

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/widgets"

payload = {
    "allow_hash_in_url": False,
    "allow_query_in_url": False,
    "auto_detect_source_language": False,
    "created_at": "",
    "elements": "",
    "follow_user": False,
    "force_cache_refresh_interval": False,
    "id": 0,
    "language_mappings": "",
    "live": False,
    "modify_links": False,
    "name": "",
    "optimize_per_page": False,
    "pages": "",
    "path_regex": "",
    "position": "",
    "query_name": "",
    "reboot_on_url_change": False,
    "restricted_domains": "",
    "sections": "",
    "test_mode": False,
    "theme": "",
    "token": "",
    "url_change_mode": "",
    "url_mode": "",
    "use_cache": False,
    "use_dummy_translations": False,
    "variables": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/widgets"

payload <- "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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}}/continuous_projects/:projectId/widgets")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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/continuous_projects/:projectId/widgets') do |req|
  req.body = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "allow_hash_in_url": false,
        "allow_query_in_url": false,
        "auto_detect_source_language": false,
        "created_at": "",
        "elements": "",
        "follow_user": false,
        "force_cache_refresh_interval": false,
        "id": 0,
        "language_mappings": "",
        "live": false,
        "modify_links": false,
        "name": "",
        "optimize_per_page": false,
        "pages": "",
        "path_regex": "",
        "position": "",
        "query_name": "",
        "reboot_on_url_change": false,
        "restricted_domains": "",
        "sections": "",
        "test_mode": false,
        "theme": "",
        "token": "",
        "url_change_mode": "",
        "url_mode": "",
        "use_cache": false,
        "use_dummy_translations": false,
        "variables": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}' |  \
  http POST {{baseUrl}}/continuous_projects/:projectId/widgets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "allow_hash_in_url": false,\n  "allow_query_in_url": false,\n  "auto_detect_source_language": false,\n  "created_at": "",\n  "elements": "",\n  "follow_user": false,\n  "force_cache_refresh_interval": false,\n  "id": 0,\n  "language_mappings": "",\n  "live": false,\n  "modify_links": false,\n  "name": "",\n  "optimize_per_page": false,\n  "pages": "",\n  "path_regex": "",\n  "position": "",\n  "query_name": "",\n  "reboot_on_url_change": false,\n  "restricted_domains": "",\n  "sections": "",\n  "test_mode": false,\n  "theme": "",\n  "token": "",\n  "url_change_mode": "",\n  "url_mode": "",\n  "use_cache": false,\n  "use_dummy_translations": false,\n  "variables": ""\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/widgets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/subscription");

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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:id/subscription" {:content-type :json
                                                                                 :form-params {:downgrade []
                                                                                               :payment_method 0
                                                                                               :period_end ""
                                                                                               :plan_id ""
                                                                                               :plan_name ""
                                                                                               :price ""
                                                                                               :products []
                                                                                               :schedule_name ""
                                                                                               :schedule_start ""
                                                                                               :subscription_id ""
                                                                                               :upgrade []
                                                                                               :withTrial ""}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/subscription"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription"),
    Content = new StringContent("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/subscription"

	payload := strings.NewReader("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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/continuous_projects/:id/subscription HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 241

{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/subscription")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/subscription"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/subscription")
  .header("content-type", "application/json")
  .body("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/continuous_projects/:id/subscription');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/subscription',
  headers: {'content-type': 'application/json'},
  data: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  }
};

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

const url = '{{baseUrl}}/continuous_projects/:id/subscription';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/subscription',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "downgrade": [],\n  "payment_method": 0,\n  "period_end": "",\n  "plan_id": "",\n  "plan_name": "",\n  "price": "",\n  "products": [],\n  "schedule_name": "",\n  "schedule_start": "",\n  "subscription_id": "",\n  "upgrade": [],\n  "withTrial": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription")
  .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/continuous_projects/:id/subscription',
  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({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/subscription',
  headers: {'content-type': 'application/json'},
  body: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  },
  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}}/continuous_projects/:id/subscription');

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

req.type('json');
req.send({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
});

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}}/continuous_projects/:id/subscription',
  headers: {'content-type': 'application/json'},
  data: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  }
};

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

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

const url = '{{baseUrl}}/continuous_projects/:id/subscription';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""}'
};

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 = @{ @"downgrade": @[  ],
                              @"payment_method": @0,
                              @"period_end": @"",
                              @"plan_id": @"",
                              @"plan_name": @"",
                              @"price": @"",
                              @"products": @[  ],
                              @"schedule_name": @"",
                              @"schedule_start": @"",
                              @"subscription_id": @"",
                              @"upgrade": @[  ],
                              @"withTrial": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/subscription"]
                                                       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}}/continuous_projects/:id/subscription" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}" in

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

 "{{baseUrl}}/continuous_projects/:id/subscription",
  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([
    'downgrade' => [
        
    ],
    'payment_method' => 0,
    'period_end' => '',
    'plan_id' => '',
    'plan_name' => '',
    'price' => '',
    'products' => [
        
    ],
    'schedule_name' => '',
    'schedule_start' => '',
    'subscription_id' => '',
    'upgrade' => [
        
    ],
    'withTrial' => ''
  ]),
  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}}/continuous_projects/:id/subscription', [
  'body' => '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/subscription');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'downgrade' => [
    
  ],
  'payment_method' => 0,
  'period_end' => '',
  'plan_id' => '',
  'plan_name' => '',
  'price' => '',
  'products' => [
    
  ],
  'schedule_name' => '',
  'schedule_start' => '',
  'subscription_id' => '',
  'upgrade' => [
    
  ],
  'withTrial' => ''
]));

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

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

append(json_encode([
  'downgrade' => [
    
  ],
  'payment_method' => 0,
  'period_end' => '',
  'plan_id' => '',
  'plan_name' => '',
  'price' => '',
  'products' => [
    
  ],
  'schedule_name' => '',
  'schedule_start' => '',
  'subscription_id' => '',
  'upgrade' => [
    
  ],
  'withTrial' => ''
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id/subscription');
$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}}/continuous_projects/:id/subscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/subscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}'

import http.client

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

payload = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}"

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

conn.request("POST", "/baseUrl/continuous_projects/:id/subscription", payload, headers)

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id/subscription"

payload = {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/subscription"

payload <- "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription")

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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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/continuous_projects/:id/subscription') do |req|
  req.body = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "downgrade": (),
        "payment_method": 0,
        "period_end": "",
        "plan_id": "",
        "plan_name": "",
        "price": "",
        "products": (),
        "schedule_name": "",
        "schedule_start": "",
        "subscription_id": "",
        "upgrade": (),
        "withTrial": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}' |  \
  http POST {{baseUrl}}/continuous_projects/:id/subscription \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "downgrade": [],\n  "payment_method": 0,\n  "period_end": "",\n  "plan_id": "",\n  "plan_name": "",\n  "price": "",\n  "products": [],\n  "schedule_name": "",\n  "schedule_start": "",\n  "subscription_id": "",\n  "upgrade": [],\n  "withTrial": ""\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/subscription

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/continuous_projects/:id")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/: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/continuous_projects/:id HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/continuous_projects/: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}}/continuous_projects/:id');

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/: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/continuous_projects/: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}}/continuous_projects/: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}}/continuous_projects/: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}}/continuous_projects/:id'};

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

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

const url = '{{baseUrl}}/continuous_projects/: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}}/continuous_projects/: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}}/continuous_projects/:id" in

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

 "{{baseUrl}}/continuous_projects/: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}}/continuous_projects/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/continuous_projects/:id")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/: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/continuous_projects/: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}}/continuous_projects/:id";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/continuous_projects/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

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

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

	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/continuous_projects/:projectId/widgets/:widgetId HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .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}}/continuous_projects/:projectId/widgets/:widgetId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId'
};

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

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId';
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}}/continuous_projects/:projectId/widgets/:widgetId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');

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}}/continuous_projects/:projectId/widgets/:widgetId'
};

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

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

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId';
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}}/continuous_projects/:projectId/widgets/:widgetId"]
                                                       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}}/continuous_projects/:projectId/widgets/:widgetId" in

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

 "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId",
  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}}/continuous_projects/:projectId/widgets/:widgetId');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/continuous_projects/:projectId/widgets/:widgetId")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")

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/continuous_projects/:projectId/widgets/:widgetId') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/subscription");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/continuous_projects/:id/subscription")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/subscription"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/subscription"

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

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/continuous_projects/:id/subscription")
  .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}}/continuous_projects/:id/subscription');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/continuous_projects/:id/subscription'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/continuous_projects/:id/subscription');

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}}/continuous_projects/:id/subscription'
};

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

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

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

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

 "{{baseUrl}}/continuous_projects/:id/subscription",
  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}}/continuous_projects/:id/subscription');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/subscription');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/subscription' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/subscription' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/continuous_projects/:id/subscription")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id/subscription"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/subscription"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/subscription")

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/continuous_projects/:id/subscription') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/continuous_projects/:id/subscription

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/subscription

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/analytics-token");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/continuous_projects/:id/analytics-token")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/analytics-token"

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

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

var client = new RestClient("{{baseUrl}}/continuous_projects/:id/analytics-token");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/analytics-token"

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

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

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

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

}

GET /baseUrl/continuous_projects/:id/analytics-token HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/analytics-token"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/analytics-token")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:id/analytics-token")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/continuous_projects/:id/analytics-token');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:id/analytics-token'
};

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

const url = '{{baseUrl}}/continuous_projects/:id/analytics-token';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/analytics-token',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/analytics-token")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:id/analytics-token',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:id/analytics-token'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:id/analytics-token');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:id/analytics-token'
};

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

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

const url = '{{baseUrl}}/continuous_projects/:id/analytics-token';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/analytics-token"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/continuous_projects/:id/analytics-token" in

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

 "{{baseUrl}}/continuous_projects/:id/analytics-token",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/continuous_projects/:id/analytics-token');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/analytics-token');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/continuous_projects/:id/analytics-token');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/analytics-token' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/analytics-token' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/continuous_projects/:id/analytics-token")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id/analytics-token"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/analytics-token"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/analytics-token")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/continuous_projects/:id/analytics-token') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/analytics-token";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:id/analytics-token

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/analytics-token

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote"

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

var client = new RestClient("{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote"

	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/continuous_projects/:id/documents/:documentId/quote HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote"))
    .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}}/continuous_projects/:id/documents/:documentId/quote")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote")
  .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}}/continuous_projects/:id/documents/:documentId/quote');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote'
};

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

const url = '{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote';
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}}/continuous_projects/:id/documents/:documentId/quote',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:id/documents/:documentId/quote',
  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}}/continuous_projects/:id/documents/:documentId/quote'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote');

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}}/continuous_projects/:id/documents/:documentId/quote'
};

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

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

const url = '{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote';
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}}/continuous_projects/:id/documents/:documentId/quote"]
                                                       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}}/continuous_projects/:id/documents/:documentId/quote" in

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

 "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote",
  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}}/continuous_projects/:id/documents/:documentId/quote');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/continuous_projects/:id/documents/:documentId/quote")

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote")

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/continuous_projects/:id/documents/:documentId/quote') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/continuous_projects/:id/documents/:documentId/quote

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/documents/:documentId/quote

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/documents/:documentId/quote")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/documents/progress");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/continuous_projects/:projectId/documents/progress" {:content-type :json
                                                                                              :form-params {:documentName ""
                                                                                                            :filterByLanguage ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/documents/progress"

	payload := strings.NewReader("{\n  \"documentName\": \"\",\n  \"filterByLanguage\": \"\"\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/continuous_projects/:projectId/documents/progress HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "documentName": "",
  "filterByLanguage": ""
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:projectId/documents/progress")
  .header("content-type", "application/json")
  .body("{\n  \"documentName\": \"\",\n  \"filterByLanguage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  documentName: '',
  filterByLanguage: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/continuous_projects/:projectId/documents/progress');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents/progress',
  headers: {'content-type': 'application/json'},
  data: {documentName: '', filterByLanguage: ''}
};

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

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/progress';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"documentName":"","filterByLanguage":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:projectId/documents/progress',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "documentName": "",\n  "filterByLanguage": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents/progress',
  headers: {'content-type': 'application/json'},
  body: {documentName: '', filterByLanguage: ''},
  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}}/continuous_projects/:projectId/documents/progress');

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

req.type('json');
req.send({
  documentName: '',
  filterByLanguage: ''
});

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}}/continuous_projects/:projectId/documents/progress',
  headers: {'content-type': 'application/json'},
  data: {documentName: '', filterByLanguage: ''}
};

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

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

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/progress';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"documentName":"","filterByLanguage":""}'
};

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

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

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

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

 "{{baseUrl}}/continuous_projects/:projectId/documents/progress",
  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([
    'documentName' => '',
    'filterByLanguage' => ''
  ]),
  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}}/continuous_projects/:projectId/documents/progress', [
  'body' => '{
  "documentName": "",
  "filterByLanguage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/documents/progress');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'documentName' => '',
  'filterByLanguage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/documents/progress');
$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}}/continuous_projects/:projectId/documents/progress' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "documentName": "",
  "filterByLanguage": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/documents/progress' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "documentName": "",
  "filterByLanguage": ""
}'

import http.client

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

payload = "{\n  \"documentName\": \"\",\n  \"filterByLanguage\": \"\"\n}"

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

conn.request("POST", "/baseUrl/continuous_projects/:projectId/documents/progress", payload, headers)

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

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

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/documents/progress"

payload = {
    "documentName": "",
    "filterByLanguage": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/documents/progress"

payload <- "{\n  \"documentName\": \"\",\n  \"filterByLanguage\": \"\"\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}}/continuous_projects/:projectId/documents/progress")

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  \"documentName\": \"\",\n  \"filterByLanguage\": \"\"\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/continuous_projects/:projectId/documents/progress') do |req|
  req.body = "{\n  \"documentName\": \"\",\n  \"filterByLanguage\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "documentName": "",
        "filterByLanguage": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "documentName": "",
  "filterByLanguage": ""
}' |  \
  http POST {{baseUrl}}/continuous_projects/:projectId/documents/progress \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "documentName": "",\n  "filterByLanguage": ""\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/documents/progress

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/documents/progress")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/documents/quote");

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  \"files\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:id/documents/quote" {:content-type :json
                                                                                    :form-params {:files []}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/documents/quote"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"files\": []\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}}/continuous_projects/:id/documents/quote"),
    Content = new StringContent("{\n  \"files\": []\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}}/continuous_projects/:id/documents/quote");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"files\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/documents/quote"

	payload := strings.NewReader("{\n  \"files\": []\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/continuous_projects/:id/documents/quote HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "files": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/documents/quote")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"files\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/documents/quote"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"files\": []\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  \"files\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/documents/quote")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/documents/quote")
  .header("content-type", "application/json")
  .body("{\n  \"files\": []\n}")
  .asString();

const data = JSON.stringify({
  files: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/continuous_projects/:id/documents/quote');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/documents/quote',
  headers: {'content-type': 'application/json'},
  data: {files: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/documents/quote';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"files":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/documents/quote',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "files": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"files\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/documents/quote")
  .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/continuous_projects/:id/documents/quote',
  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({files: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/documents/quote',
  headers: {'content-type': 'application/json'},
  body: {files: []},
  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}}/continuous_projects/:id/documents/quote');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  files: []
});

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}}/continuous_projects/:id/documents/quote',
  headers: {'content-type': 'application/json'},
  data: {files: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/documents/quote';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"files":[]}'
};

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 = @{ @"files": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/documents/quote"]
                                                       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}}/continuous_projects/:id/documents/quote" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"files\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/documents/quote",
  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([
    'files' => [
        
    ]
  ]),
  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}}/continuous_projects/:id/documents/quote', [
  'body' => '{
  "files": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/documents/quote');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'files' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'files' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id/documents/quote');
$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}}/continuous_projects/:id/documents/quote' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "files": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/documents/quote' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "files": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"files\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/continuous_projects/:id/documents/quote", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/documents/quote"

payload = { "files": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/documents/quote"

payload <- "{\n  \"files\": []\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}}/continuous_projects/:id/documents/quote")

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  \"files\": []\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/continuous_projects/:id/documents/quote') do |req|
  req.body = "{\n  \"files\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/documents/quote";

    let payload = json!({"files": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "files": []
}' |  \
  http POST {{baseUrl}}/continuous_projects/:id/documents/quote \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "files": []\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/documents/quote

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["files": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/documents/quote")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote"

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}}/continuous_projects/:id/languages/:targetLanguage/quote"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote"

	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/continuous_projects/:id/languages/:targetLanguage/quote HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote"))
    .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}}/continuous_projects/:id/languages/:targetLanguage/quote")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote")
  .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}}/continuous_projects/:id/languages/:targetLanguage/quote');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote';
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}}/continuous_projects/:id/languages/:targetLanguage/quote',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:id/languages/:targetLanguage/quote',
  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}}/continuous_projects/:id/languages/:targetLanguage/quote'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote');

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}}/continuous_projects/:id/languages/:targetLanguage/quote'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote';
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}}/continuous_projects/:id/languages/:targetLanguage/quote"]
                                                       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}}/continuous_projects/:id/languages/:targetLanguage/quote" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote",
  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}}/continuous_projects/:id/languages/:targetLanguage/quote');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/continuous_projects/:id/languages/:targetLanguage/quote")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote")

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/continuous_projects/:id/languages/:targetLanguage/quote') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/languages/:targetLanguage/quote")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/languages/quote");

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  \"languages\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:id/languages/quote" {:content-type :json
                                                                                    :form-params {:languages []}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/languages/quote"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"languages\": []\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}}/continuous_projects/:id/languages/quote"),
    Content = new StringContent("{\n  \"languages\": []\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}}/continuous_projects/:id/languages/quote");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"languages\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/languages/quote"

	payload := strings.NewReader("{\n  \"languages\": []\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/continuous_projects/:id/languages/quote HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "languages": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/languages/quote")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"languages\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/languages/quote"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"languages\": []\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  \"languages\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/languages/quote")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/languages/quote")
  .header("content-type", "application/json")
  .body("{\n  \"languages\": []\n}")
  .asString();

const data = JSON.stringify({
  languages: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/continuous_projects/:id/languages/quote');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/languages/quote',
  headers: {'content-type': 'application/json'},
  data: {languages: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/languages/quote';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"languages":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/languages/quote',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "languages": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"languages\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/languages/quote")
  .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/continuous_projects/:id/languages/quote',
  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({languages: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/languages/quote',
  headers: {'content-type': 'application/json'},
  body: {languages: []},
  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}}/continuous_projects/:id/languages/quote');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  languages: []
});

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}}/continuous_projects/:id/languages/quote',
  headers: {'content-type': 'application/json'},
  data: {languages: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/languages/quote';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"languages":[]}'
};

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 = @{ @"languages": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/languages/quote"]
                                                       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}}/continuous_projects/:id/languages/quote" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"languages\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/languages/quote",
  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([
    'languages' => [
        
    ]
  ]),
  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}}/continuous_projects/:id/languages/quote', [
  'body' => '{
  "languages": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/languages/quote');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'languages' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'languages' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id/languages/quote');
$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}}/continuous_projects/:id/languages/quote' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "languages": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/languages/quote' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "languages": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"languages\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/continuous_projects/:id/languages/quote", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/languages/quote"

payload = { "languages": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/languages/quote"

payload <- "{\n  \"languages\": []\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}}/continuous_projects/:id/languages/quote")

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  \"languages\": []\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/continuous_projects/:id/languages/quote') do |req|
  req.body = "{\n  \"languages\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/languages/quote";

    let payload = json!({"languages": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "languages": []
}' |  \
  http POST {{baseUrl}}/continuous_projects/:id/languages/quote \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "languages": []\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/languages/quote

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["languages": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/languages/quote")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/subscription");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:id/subscription")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/subscription"

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}}/continuous_projects/:id/subscription"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:id/subscription");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/subscription"

	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/continuous_projects/:id/subscription HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:id/subscription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/subscription"))
    .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}}/continuous_projects/:id/subscription")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:id/subscription")
  .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}}/continuous_projects/:id/subscription');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:id/subscription'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/subscription';
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}}/continuous_projects/:id/subscription',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:id/subscription',
  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}}/continuous_projects/:id/subscription'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:id/subscription');

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}}/continuous_projects/:id/subscription'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/subscription';
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}}/continuous_projects/:id/subscription"]
                                                       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}}/continuous_projects/:id/subscription" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/subscription",
  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}}/continuous_projects/:id/subscription');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/subscription');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:id/subscription');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id/subscription' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/subscription' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:id/subscription")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/subscription"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/subscription"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:id/subscription")

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/continuous_projects/:id/subscription') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/subscription";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:id/subscription

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/subscription

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/subscription")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage");

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  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage" {:content-type :json
                                                                                              :form-params {:contents []
                                                                                                            :documents [{:data ""
                                                                                                                         :name ""}]
                                                                                                            :filters {:skipMt []
                                                                                                                      :skipPostEdit []}
                                                                                                            :meta {}}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\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}}/continuous_projects/:id/translate/:targetLanguage"),
    Content = new StringContent("{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\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}}/continuous_projects/:id/translate/:targetLanguage");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage"

	payload := strings.NewReader("{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\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/continuous_projects/:id/translate/:targetLanguage HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 164

{
  "contents": [],
  "documents": [
    {
      "data": "",
      "name": ""
    }
  ],
  "filters": {
    "skipMt": [],
    "skipPostEdit": []
  },
  "meta": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\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  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage")
  .header("content-type", "application/json")
  .body("{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}")
  .asString();

const data = JSON.stringify({
  contents: [],
  documents: [
    {
      data: '',
      name: ''
    }
  ],
  filters: {
    skipMt: [],
    skipPostEdit: []
  },
  meta: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage',
  headers: {'content-type': 'application/json'},
  data: {
    contents: [],
    documents: [{data: '', name: ''}],
    filters: {skipMt: [], skipPostEdit: []},
    meta: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contents":[],"documents":[{"data":"","name":""}],"filters":{"skipMt":[],"skipPostEdit":[]},"meta":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contents": [],\n  "documents": [\n    {\n      "data": "",\n      "name": ""\n    }\n  ],\n  "filters": {\n    "skipMt": [],\n    "skipPostEdit": []\n  },\n  "meta": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage")
  .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/continuous_projects/:id/translate/:targetLanguage',
  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({
  contents: [],
  documents: [{data: '', name: ''}],
  filters: {skipMt: [], skipPostEdit: []},
  meta: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage',
  headers: {'content-type': 'application/json'},
  body: {
    contents: [],
    documents: [{data: '', name: ''}],
    filters: {skipMt: [], skipPostEdit: []},
    meta: {}
  },
  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}}/continuous_projects/:id/translate/:targetLanguage');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  contents: [],
  documents: [
    {
      data: '',
      name: ''
    }
  ],
  filters: {
    skipMt: [],
    skipPostEdit: []
  },
  meta: {}
});

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}}/continuous_projects/:id/translate/:targetLanguage',
  headers: {'content-type': 'application/json'},
  data: {
    contents: [],
    documents: [{data: '', name: ''}],
    filters: {skipMt: [], skipPostEdit: []},
    meta: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contents":[],"documents":[{"data":"","name":""}],"filters":{"skipMt":[],"skipPostEdit":[]},"meta":{}}'
};

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 = @{ @"contents": @[  ],
                              @"documents": @[ @{ @"data": @"", @"name": @"" } ],
                              @"filters": @{ @"skipMt": @[  ], @"skipPostEdit": @[  ] },
                              @"meta": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage"]
                                                       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}}/continuous_projects/:id/translate/:targetLanguage" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage",
  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([
    'contents' => [
        
    ],
    'documents' => [
        [
                'data' => '',
                'name' => ''
        ]
    ],
    'filters' => [
        'skipMt' => [
                
        ],
        'skipPostEdit' => [
                
        ]
    ],
    'meta' => [
        
    ]
  ]),
  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}}/continuous_projects/:id/translate/:targetLanguage', [
  'body' => '{
  "contents": [],
  "documents": [
    {
      "data": "",
      "name": ""
    }
  ],
  "filters": {
    "skipMt": [],
    "skipPostEdit": []
  },
  "meta": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contents' => [
    
  ],
  'documents' => [
    [
        'data' => '',
        'name' => ''
    ]
  ],
  'filters' => [
    'skipMt' => [
        
    ],
    'skipPostEdit' => [
        
    ]
  ],
  'meta' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'contents' => [
    
  ],
  'documents' => [
    [
        'data' => '',
        'name' => ''
    ]
  ],
  'filters' => [
    'skipMt' => [
        
    ],
    'skipPostEdit' => [
        
    ]
  ],
  'meta' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage');
$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}}/continuous_projects/:id/translate/:targetLanguage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contents": [],
  "documents": [
    {
      "data": "",
      "name": ""
    }
  ],
  "filters": {
    "skipMt": [],
    "skipPostEdit": []
  },
  "meta": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contents": [],
  "documents": [
    {
      "data": "",
      "name": ""
    }
  ],
  "filters": {
    "skipMt": [],
    "skipPostEdit": []
  },
  "meta": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/continuous_projects/:id/translate/:targetLanguage", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage"

payload = {
    "contents": [],
    "documents": [
        {
            "data": "",
            "name": ""
        }
    ],
    "filters": {
        "skipMt": [],
        "skipPostEdit": []
    },
    "meta": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage"

payload <- "{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\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}}/continuous_projects/:id/translate/:targetLanguage")

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  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\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/continuous_projects/:id/translate/:targetLanguage') do |req|
  req.body = "{\n  \"contents\": [],\n  \"documents\": [\n    {\n      \"data\": \"\",\n      \"name\": \"\"\n    }\n  ],\n  \"filters\": {\n    \"skipMt\": [],\n    \"skipPostEdit\": []\n  },\n  \"meta\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage";

    let payload = json!({
        "contents": (),
        "documents": (
            json!({
                "data": "",
                "name": ""
            })
        ),
        "filters": json!({
            "skipMt": (),
            "skipPostEdit": ()
        }),
        "meta": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "contents": [],
  "documents": [
    {
      "data": "",
      "name": ""
    }
  ],
  "filters": {
    "skipMt": [],
    "skipPostEdit": []
  },
  "meta": {}
}' |  \
  http POST {{baseUrl}}/continuous_projects/:id/translate/:targetLanguage \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "contents": [],\n  "documents": [\n    {\n      "data": "",\n      "name": ""\n    }\n  ],\n  "filters": {\n    "skipMt": [],\n    "skipPostEdit": []\n  },\n  "meta": {}\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/translate/:targetLanguage

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contents": [],
  "documents": [
    [
      "data": "",
      "name": ""
    ]
  ],
  "filters": [
    "skipMt": [],
    "skipPostEdit": []
  ],
  "meta": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/translate/:targetLanguage")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/invoices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:projectId/invoices")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/invoices"

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}}/continuous_projects/:projectId/invoices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/invoices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/invoices"

	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/continuous_projects/:projectId/invoices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:projectId/invoices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/invoices"))
    .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}}/continuous_projects/:projectId/invoices")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:projectId/invoices")
  .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}}/continuous_projects/:projectId/invoices');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:projectId/invoices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/invoices';
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}}/continuous_projects/:projectId/invoices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/invoices")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/invoices',
  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}}/continuous_projects/:projectId/invoices'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:projectId/invoices');

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}}/continuous_projects/:projectId/invoices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/invoices';
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}}/continuous_projects/:projectId/invoices"]
                                                       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}}/continuous_projects/:projectId/invoices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/invoices",
  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}}/continuous_projects/:projectId/invoices');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/invoices');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/invoices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/invoices' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/invoices' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:projectId/invoices")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/invoices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/invoices"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/invoices")

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/continuous_projects/:projectId/invoices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/invoices";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:projectId/invoices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/invoices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/invoices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/progress");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:projectId/progress")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/progress"

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}}/continuous_projects/:projectId/progress"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/progress");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/progress"

	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/continuous_projects/:projectId/progress HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:projectId/progress")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/progress"))
    .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}}/continuous_projects/:projectId/progress")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:projectId/progress")
  .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}}/continuous_projects/:projectId/progress');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:projectId/progress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/progress';
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}}/continuous_projects/:projectId/progress',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/progress")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/progress',
  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}}/continuous_projects/:projectId/progress'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:projectId/progress');

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}}/continuous_projects/:projectId/progress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/progress';
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}}/continuous_projects/:projectId/progress"]
                                                       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}}/continuous_projects/:projectId/progress" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/progress",
  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}}/continuous_projects/:projectId/progress');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/progress');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/progress');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/progress' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/progress' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:projectId/progress")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/progress"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/progress"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/progress")

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/continuous_projects/:projectId/progress') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/progress";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:projectId/progress

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/progress

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/progress")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress"

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}}/continuous_projects/:projectId/documents/:documentId/progress"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress"

	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/continuous_projects/:projectId/documents/:documentId/progress HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress"))
    .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}}/continuous_projects/:projectId/documents/:documentId/progress")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress")
  .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}}/continuous_projects/:projectId/documents/:documentId/progress');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress';
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}}/continuous_projects/:projectId/documents/:documentId/progress',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/documents/:documentId/progress',
  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}}/continuous_projects/:projectId/documents/:documentId/progress'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress');

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}}/continuous_projects/:projectId/documents/:documentId/progress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress';
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}}/continuous_projects/:projectId/documents/:documentId/progress"]
                                                       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}}/continuous_projects/:projectId/documents/:documentId/progress" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress",
  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}}/continuous_projects/:projectId/documents/:documentId/progress');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:projectId/documents/:documentId/progress")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress")

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/continuous_projects/:projectId/documents/:documentId/progress') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId/progress")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token"

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}}/continuous_projects/:projectId/widgets/:widgetId/reset-token"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token"

	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/continuous_projects/:projectId/widgets/:widgetId/reset-token HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token"))
    .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}}/continuous_projects/:projectId/widgets/:widgetId/reset-token")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token';
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}}/continuous_projects/:projectId/widgets/:widgetId/reset-token',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/widgets/:widgetId/reset-token',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token';
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}}/continuous_projects/:projectId/widgets/:widgetId/reset-token"]
                                                       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}}/continuous_projects/:projectId/widgets/:widgetId/reset-token" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token",
  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}}/continuous_projects/:projectId/widgets/:widgetId/reset-token');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/continuous_projects/:projectId/widgets/:widgetId/reset-token")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token")

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/continuous_projects/:projectId/widgets/:widgetId/reset-token') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId/reset-token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/collect-analytics");

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  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:id/collect-analytics" {:content-type :json
                                                                                      :form-params {:anonymousId ""
                                                                                                    :properties {}
                                                                                                    :sessionId ""
                                                                                                    :type ""
                                                                                                    :userId ""}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/collect-analytics"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\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}}/continuous_projects/:id/collect-analytics"),
    Content = new StringContent("{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\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}}/continuous_projects/:id/collect-analytics");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/collect-analytics"

	payload := strings.NewReader("{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\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/continuous_projects/:id/collect-analytics HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "anonymousId": "",
  "properties": {},
  "sessionId": "",
  "type": "",
  "userId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id/collect-analytics")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/collect-analytics"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\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  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/collect-analytics")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id/collect-analytics")
  .header("content-type", "application/json")
  .body("{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  anonymousId: '',
  properties: {},
  sessionId: '',
  type: '',
  userId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/continuous_projects/:id/collect-analytics');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/collect-analytics',
  headers: {'content-type': 'application/json'},
  data: {anonymousId: '', properties: {}, sessionId: '', type: '', userId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/collect-analytics';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"anonymousId":"","properties":{},"sessionId":"","type":"","userId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/collect-analytics',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "anonymousId": "",\n  "properties": {},\n  "sessionId": "",\n  "type": "",\n  "userId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/collect-analytics")
  .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/continuous_projects/:id/collect-analytics',
  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({anonymousId: '', properties: {}, sessionId: '', type: '', userId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id/collect-analytics',
  headers: {'content-type': 'application/json'},
  body: {anonymousId: '', properties: {}, sessionId: '', type: '', userId: ''},
  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}}/continuous_projects/:id/collect-analytics');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  anonymousId: '',
  properties: {},
  sessionId: '',
  type: '',
  userId: ''
});

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}}/continuous_projects/:id/collect-analytics',
  headers: {'content-type': 'application/json'},
  data: {anonymousId: '', properties: {}, sessionId: '', type: '', userId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/collect-analytics';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"anonymousId":"","properties":{},"sessionId":"","type":"","userId":""}'
};

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 = @{ @"anonymousId": @"",
                              @"properties": @{  },
                              @"sessionId": @"",
                              @"type": @"",
                              @"userId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/collect-analytics"]
                                                       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}}/continuous_projects/:id/collect-analytics" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/collect-analytics",
  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([
    'anonymousId' => '',
    'properties' => [
        
    ],
    'sessionId' => '',
    'type' => '',
    'userId' => ''
  ]),
  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}}/continuous_projects/:id/collect-analytics', [
  'body' => '{
  "anonymousId": "",
  "properties": {},
  "sessionId": "",
  "type": "",
  "userId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/collect-analytics');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'anonymousId' => '',
  'properties' => [
    
  ],
  'sessionId' => '',
  'type' => '',
  'userId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'anonymousId' => '',
  'properties' => [
    
  ],
  'sessionId' => '',
  'type' => '',
  'userId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id/collect-analytics');
$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}}/continuous_projects/:id/collect-analytics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "anonymousId": "",
  "properties": {},
  "sessionId": "",
  "type": "",
  "userId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/collect-analytics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "anonymousId": "",
  "properties": {},
  "sessionId": "",
  "type": "",
  "userId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/continuous_projects/:id/collect-analytics", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/collect-analytics"

payload = {
    "anonymousId": "",
    "properties": {},
    "sessionId": "",
    "type": "",
    "userId": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/collect-analytics"

payload <- "{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\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}}/continuous_projects/:id/collect-analytics")

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  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\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/continuous_projects/:id/collect-analytics') do |req|
  req.body = "{\n  \"anonymousId\": \"\",\n  \"properties\": {},\n  \"sessionId\": \"\",\n  \"type\": \"\",\n  \"userId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id/collect-analytics";

    let payload = json!({
        "anonymousId": "",
        "properties": json!({}),
        "sessionId": "",
        "type": "",
        "userId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "anonymousId": "",
  "properties": {},
  "sessionId": "",
  "type": "",
  "userId": ""
}' |  \
  http POST {{baseUrl}}/continuous_projects/:id/collect-analytics \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "anonymousId": "",\n  "properties": {},\n  "sessionId": "",\n  "type": "",\n  "userId": ""\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/collect-analytics

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "anonymousId": "",
  "properties": [],
  "sessionId": "",
  "type": "",
  "userId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/collect-analytics")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId" {:content-type :json
                                                                                             :form-params {:allow_hash_in_url false
                                                                                                           :allow_query_in_url false
                                                                                                           :auto_detect_source_language false
                                                                                                           :created_at ""
                                                                                                           :elements ""
                                                                                                           :follow_user false
                                                                                                           :force_cache_refresh_interval false
                                                                                                           :id 0
                                                                                                           :language_mappings ""
                                                                                                           :live false
                                                                                                           :modify_links false
                                                                                                           :name ""
                                                                                                           :optimize_per_page false
                                                                                                           :pages ""
                                                                                                           :path_regex ""
                                                                                                           :position ""
                                                                                                           :query_name ""
                                                                                                           :reboot_on_url_change false
                                                                                                           :restricted_domains ""
                                                                                                           :sections ""
                                                                                                           :test_mode false
                                                                                                           :theme ""
                                                                                                           :token ""
                                                                                                           :url_change_mode ""
                                                                                                           :url_mode ""
                                                                                                           :use_cache false
                                                                                                           :use_dummy_translations false
                                                                                                           :variables ""}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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}}/continuous_projects/:projectId/widgets/:widgetId"),
    Content = new StringContent("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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}}/continuous_projects/:projectId/widgets/:widgetId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

	payload := strings.NewReader("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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/continuous_projects/:projectId/widgets/:widgetId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 653

{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .header("content-type", "application/json")
  .body("{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  allow_hash_in_url: false,
  allow_query_in_url: false,
  auto_detect_source_language: false,
  created_at: '',
  elements: '',
  follow_user: false,
  force_cache_refresh_interval: false,
  id: 0,
  language_mappings: '',
  live: false,
  modify_links: false,
  name: '',
  optimize_per_page: false,
  pages: '',
  path_regex: '',
  position: '',
  query_name: '',
  reboot_on_url_change: false,
  restricted_domains: '',
  sections: '',
  test_mode: false,
  theme: '',
  token: '',
  url_change_mode: '',
  url_mode: '',
  use_cache: false,
  use_dummy_translations: false,
  variables: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId',
  headers: {'content-type': 'application/json'},
  data: {
    allow_hash_in_url: false,
    allow_query_in_url: false,
    auto_detect_source_language: false,
    created_at: '',
    elements: '',
    follow_user: false,
    force_cache_refresh_interval: false,
    id: 0,
    language_mappings: '',
    live: false,
    modify_links: false,
    name: '',
    optimize_per_page: false,
    pages: '',
    path_regex: '',
    position: '',
    query_name: '',
    reboot_on_url_change: false,
    restricted_domains: '',
    sections: '',
    test_mode: false,
    theme: '',
    token: '',
    url_change_mode: '',
    url_mode: '',
    use_cache: false,
    use_dummy_translations: false,
    variables: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allow_hash_in_url":false,"allow_query_in_url":false,"auto_detect_source_language":false,"created_at":"","elements":"","follow_user":false,"force_cache_refresh_interval":false,"id":0,"language_mappings":"","live":false,"modify_links":false,"name":"","optimize_per_page":false,"pages":"","path_regex":"","position":"","query_name":"","reboot_on_url_change":false,"restricted_domains":"","sections":"","test_mode":false,"theme":"","token":"","url_change_mode":"","url_mode":"","use_cache":false,"use_dummy_translations":false,"variables":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "allow_hash_in_url": false,\n  "allow_query_in_url": false,\n  "auto_detect_source_language": false,\n  "created_at": "",\n  "elements": "",\n  "follow_user": false,\n  "force_cache_refresh_interval": false,\n  "id": 0,\n  "language_mappings": "",\n  "live": false,\n  "modify_links": false,\n  "name": "",\n  "optimize_per_page": false,\n  "pages": "",\n  "path_regex": "",\n  "position": "",\n  "query_name": "",\n  "reboot_on_url_change": false,\n  "restricted_domains": "",\n  "sections": "",\n  "test_mode": false,\n  "theme": "",\n  "token": "",\n  "url_change_mode": "",\n  "url_mode": "",\n  "use_cache": false,\n  "use_dummy_translations": false,\n  "variables": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .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/continuous_projects/:projectId/widgets/:widgetId',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  allow_hash_in_url: false,
  allow_query_in_url: false,
  auto_detect_source_language: false,
  created_at: '',
  elements: '',
  follow_user: false,
  force_cache_refresh_interval: false,
  id: 0,
  language_mappings: '',
  live: false,
  modify_links: false,
  name: '',
  optimize_per_page: false,
  pages: '',
  path_regex: '',
  position: '',
  query_name: '',
  reboot_on_url_change: false,
  restricted_domains: '',
  sections: '',
  test_mode: false,
  theme: '',
  token: '',
  url_change_mode: '',
  url_mode: '',
  use_cache: false,
  use_dummy_translations: false,
  variables: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId',
  headers: {'content-type': 'application/json'},
  body: {
    allow_hash_in_url: false,
    allow_query_in_url: false,
    auto_detect_source_language: false,
    created_at: '',
    elements: '',
    follow_user: false,
    force_cache_refresh_interval: false,
    id: 0,
    language_mappings: '',
    live: false,
    modify_links: false,
    name: '',
    optimize_per_page: false,
    pages: '',
    path_regex: '',
    position: '',
    query_name: '',
    reboot_on_url_change: false,
    restricted_domains: '',
    sections: '',
    test_mode: false,
    theme: '',
    token: '',
    url_change_mode: '',
    url_mode: '',
    use_cache: false,
    use_dummy_translations: false,
    variables: ''
  },
  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}}/continuous_projects/:projectId/widgets/:widgetId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  allow_hash_in_url: false,
  allow_query_in_url: false,
  auto_detect_source_language: false,
  created_at: '',
  elements: '',
  follow_user: false,
  force_cache_refresh_interval: false,
  id: 0,
  language_mappings: '',
  live: false,
  modify_links: false,
  name: '',
  optimize_per_page: false,
  pages: '',
  path_regex: '',
  position: '',
  query_name: '',
  reboot_on_url_change: false,
  restricted_domains: '',
  sections: '',
  test_mode: false,
  theme: '',
  token: '',
  url_change_mode: '',
  url_mode: '',
  use_cache: false,
  use_dummy_translations: false,
  variables: ''
});

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}}/continuous_projects/:projectId/widgets/:widgetId',
  headers: {'content-type': 'application/json'},
  data: {
    allow_hash_in_url: false,
    allow_query_in_url: false,
    auto_detect_source_language: false,
    created_at: '',
    elements: '',
    follow_user: false,
    force_cache_refresh_interval: false,
    id: 0,
    language_mappings: '',
    live: false,
    modify_links: false,
    name: '',
    optimize_per_page: false,
    pages: '',
    path_regex: '',
    position: '',
    query_name: '',
    reboot_on_url_change: false,
    restricted_domains: '',
    sections: '',
    test_mode: false,
    theme: '',
    token: '',
    url_change_mode: '',
    url_mode: '',
    use_cache: false,
    use_dummy_translations: false,
    variables: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"allow_hash_in_url":false,"allow_query_in_url":false,"auto_detect_source_language":false,"created_at":"","elements":"","follow_user":false,"force_cache_refresh_interval":false,"id":0,"language_mappings":"","live":false,"modify_links":false,"name":"","optimize_per_page":false,"pages":"","path_regex":"","position":"","query_name":"","reboot_on_url_change":false,"restricted_domains":"","sections":"","test_mode":false,"theme":"","token":"","url_change_mode":"","url_mode":"","use_cache":false,"use_dummy_translations":false,"variables":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"allow_hash_in_url": @NO,
                              @"allow_query_in_url": @NO,
                              @"auto_detect_source_language": @NO,
                              @"created_at": @"",
                              @"elements": @"",
                              @"follow_user": @NO,
                              @"force_cache_refresh_interval": @NO,
                              @"id": @0,
                              @"language_mappings": @"",
                              @"live": @NO,
                              @"modify_links": @NO,
                              @"name": @"",
                              @"optimize_per_page": @NO,
                              @"pages": @"",
                              @"path_regex": @"",
                              @"position": @"",
                              @"query_name": @"",
                              @"reboot_on_url_change": @NO,
                              @"restricted_domains": @"",
                              @"sections": @"",
                              @"test_mode": @NO,
                              @"theme": @"",
                              @"token": @"",
                              @"url_change_mode": @"",
                              @"url_mode": @"",
                              @"use_cache": @NO,
                              @"use_dummy_translations": @NO,
                              @"variables": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"]
                                                       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}}/continuous_projects/:projectId/widgets/:widgetId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'allow_hash_in_url' => null,
    'allow_query_in_url' => null,
    'auto_detect_source_language' => null,
    'created_at' => '',
    'elements' => '',
    'follow_user' => null,
    'force_cache_refresh_interval' => null,
    'id' => 0,
    'language_mappings' => '',
    'live' => null,
    'modify_links' => null,
    'name' => '',
    'optimize_per_page' => null,
    'pages' => '',
    'path_regex' => '',
    'position' => '',
    'query_name' => '',
    'reboot_on_url_change' => null,
    'restricted_domains' => '',
    'sections' => '',
    'test_mode' => null,
    'theme' => '',
    'token' => '',
    'url_change_mode' => '',
    'url_mode' => '',
    'use_cache' => null,
    'use_dummy_translations' => null,
    'variables' => ''
  ]),
  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}}/continuous_projects/:projectId/widgets/:widgetId', [
  'body' => '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'allow_hash_in_url' => null,
  'allow_query_in_url' => null,
  'auto_detect_source_language' => null,
  'created_at' => '',
  'elements' => '',
  'follow_user' => null,
  'force_cache_refresh_interval' => null,
  'id' => 0,
  'language_mappings' => '',
  'live' => null,
  'modify_links' => null,
  'name' => '',
  'optimize_per_page' => null,
  'pages' => '',
  'path_regex' => '',
  'position' => '',
  'query_name' => '',
  'reboot_on_url_change' => null,
  'restricted_domains' => '',
  'sections' => '',
  'test_mode' => null,
  'theme' => '',
  'token' => '',
  'url_change_mode' => '',
  'url_mode' => '',
  'use_cache' => null,
  'use_dummy_translations' => null,
  'variables' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'allow_hash_in_url' => null,
  'allow_query_in_url' => null,
  'auto_detect_source_language' => null,
  'created_at' => '',
  'elements' => '',
  'follow_user' => null,
  'force_cache_refresh_interval' => null,
  'id' => 0,
  'language_mappings' => '',
  'live' => null,
  'modify_links' => null,
  'name' => '',
  'optimize_per_page' => null,
  'pages' => '',
  'path_regex' => '',
  'position' => '',
  'query_name' => '',
  'reboot_on_url_change' => null,
  'restricted_domains' => '',
  'sections' => '',
  'test_mode' => null,
  'theme' => '',
  'token' => '',
  'url_change_mode' => '',
  'url_mode' => '',
  'use_cache' => null,
  'use_dummy_translations' => null,
  'variables' => ''
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');
$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}}/continuous_projects/:projectId/widgets/:widgetId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/continuous_projects/:projectId/widgets/:widgetId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

payload = {
    "allow_hash_in_url": False,
    "allow_query_in_url": False,
    "auto_detect_source_language": False,
    "created_at": "",
    "elements": "",
    "follow_user": False,
    "force_cache_refresh_interval": False,
    "id": 0,
    "language_mappings": "",
    "live": False,
    "modify_links": False,
    "name": "",
    "optimize_per_page": False,
    "pages": "",
    "path_regex": "",
    "position": "",
    "query_name": "",
    "reboot_on_url_change": False,
    "restricted_domains": "",
    "sections": "",
    "test_mode": False,
    "theme": "",
    "token": "",
    "url_change_mode": "",
    "url_mode": "",
    "use_cache": False,
    "use_dummy_translations": False,
    "variables": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

payload <- "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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}}/continuous_projects/:projectId/widgets/:widgetId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\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/continuous_projects/:projectId/widgets/:widgetId') do |req|
  req.body = "{\n  \"allow_hash_in_url\": false,\n  \"allow_query_in_url\": false,\n  \"auto_detect_source_language\": false,\n  \"created_at\": \"\",\n  \"elements\": \"\",\n  \"follow_user\": false,\n  \"force_cache_refresh_interval\": false,\n  \"id\": 0,\n  \"language_mappings\": \"\",\n  \"live\": false,\n  \"modify_links\": false,\n  \"name\": \"\",\n  \"optimize_per_page\": false,\n  \"pages\": \"\",\n  \"path_regex\": \"\",\n  \"position\": \"\",\n  \"query_name\": \"\",\n  \"reboot_on_url_change\": false,\n  \"restricted_domains\": \"\",\n  \"sections\": \"\",\n  \"test_mode\": false,\n  \"theme\": \"\",\n  \"token\": \"\",\n  \"url_change_mode\": \"\",\n  \"url_mode\": \"\",\n  \"use_cache\": false,\n  \"use_dummy_translations\": false,\n  \"variables\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId";

    let payload = json!({
        "allow_hash_in_url": false,
        "allow_query_in_url": false,
        "auto_detect_source_language": false,
        "created_at": "",
        "elements": "",
        "follow_user": false,
        "force_cache_refresh_interval": false,
        "id": 0,
        "language_mappings": "",
        "live": false,
        "modify_links": false,
        "name": "",
        "optimize_per_page": false,
        "pages": "",
        "path_regex": "",
        "position": "",
        "query_name": "",
        "reboot_on_url_change": false,
        "restricted_domains": "",
        "sections": "",
        "test_mode": false,
        "theme": "",
        "token": "",
        "url_change_mode": "",
        "url_mode": "",
        "use_cache": false,
        "use_dummy_translations": false,
        "variables": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
}' |  \
  http POST {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "allow_hash_in_url": false,\n  "allow_query_in_url": false,\n  "auto_detect_source_language": false,\n  "created_at": "",\n  "elements": "",\n  "follow_user": false,\n  "force_cache_refresh_interval": false,\n  "id": 0,\n  "language_mappings": "",\n  "live": false,\n  "modify_links": false,\n  "name": "",\n  "optimize_per_page": false,\n  "pages": "",\n  "path_regex": "",\n  "position": "",\n  "query_name": "",\n  "reboot_on_url_change": false,\n  "restricted_domains": "",\n  "sections": "",\n  "test_mode": false,\n  "theme": "",\n  "token": "",\n  "url_change_mode": "",\n  "url_mode": "",\n  "use_cache": false,\n  "use_dummy_translations": false,\n  "variables": ""\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "allow_hash_in_url": false,
  "allow_query_in_url": false,
  "auto_detect_source_language": false,
  "created_at": "",
  "elements": "",
  "follow_user": false,
  "force_cache_refresh_interval": false,
  "id": 0,
  "language_mappings": "",
  "live": false,
  "modify_links": false,
  "name": "",
  "optimize_per_page": false,
  "pages": "",
  "path_regex": "",
  "position": "",
  "query_name": "",
  "reboot_on_url_change": false,
  "restricted_domains": "",
  "sections": "",
  "test_mode": false,
  "theme": "",
  "token": "",
  "url_change_mode": "",
  "url_mode": "",
  "use_cache": false,
  "use_dummy_translations": false,
  "variables": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/: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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:id" {:content-type :json
                                                                    :form-params {:analytics_enabled false
                                                                                  :auto_start_postedit false
                                                                                  :is_enabled false
                                                                                  :languages [{:code ""
                                                                                               :is_enabled false}]
                                                                                  :mt_enabled false
                                                                                  :name ""
                                                                                  :postedit_enabled false}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": 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}}/continuous_projects/:id"),
    Content = new StringContent("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": 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}}/continuous_projects/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id"

	payload := strings.NewReader("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": 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/continuous_projects/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 231

{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "is_enabled": false,
  "languages": [
    {
      "code": "",
      "is_enabled": false
    }
  ],
  "mt_enabled": false,
  "name": "",
  "postedit_enabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": 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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:id")
  .header("content-type", "application/json")
  .body("{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}")
  .asString();

const data = JSON.stringify({
  analytics_enabled: false,
  auto_start_postedit: false,
  is_enabled: false,
  languages: [
    {
      code: '',
      is_enabled: false
    }
  ],
  mt_enabled: false,
  name: '',
  postedit_enabled: 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}}/continuous_projects/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id',
  headers: {'content-type': 'application/json'},
  data: {
    analytics_enabled: false,
    auto_start_postedit: false,
    is_enabled: false,
    languages: [{code: '', is_enabled: false}],
    mt_enabled: false,
    name: '',
    postedit_enabled: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"analytics_enabled":false,"auto_start_postedit":false,"is_enabled":false,"languages":[{"code":"","is_enabled":false}],"mt_enabled":false,"name":"","postedit_enabled":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}}/continuous_projects/:id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "analytics_enabled": false,\n  "auto_start_postedit": false,\n  "is_enabled": false,\n  "languages": [\n    {\n      "code": "",\n      "is_enabled": false\n    }\n  ],\n  "mt_enabled": false,\n  "name": "",\n  "postedit_enabled": 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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id")
  .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/continuous_projects/: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({
  analytics_enabled: false,
  auto_start_postedit: false,
  is_enabled: false,
  languages: [{code: '', is_enabled: false}],
  mt_enabled: false,
  name: '',
  postedit_enabled: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:id',
  headers: {'content-type': 'application/json'},
  body: {
    analytics_enabled: false,
    auto_start_postedit: false,
    is_enabled: false,
    languages: [{code: '', is_enabled: false}],
    mt_enabled: false,
    name: '',
    postedit_enabled: 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}}/continuous_projects/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  analytics_enabled: false,
  auto_start_postedit: false,
  is_enabled: false,
  languages: [
    {
      code: '',
      is_enabled: false
    }
  ],
  mt_enabled: false,
  name: '',
  postedit_enabled: 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}}/continuous_projects/:id',
  headers: {'content-type': 'application/json'},
  data: {
    analytics_enabled: false,
    auto_start_postedit: false,
    is_enabled: false,
    languages: [{code: '', is_enabled: false}],
    mt_enabled: false,
    name: '',
    postedit_enabled: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"analytics_enabled":false,"auto_start_postedit":false,"is_enabled":false,"languages":[{"code":"","is_enabled":false}],"mt_enabled":false,"name":"","postedit_enabled":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 = @{ @"analytics_enabled": @NO,
                              @"auto_start_postedit": @NO,
                              @"is_enabled": @NO,
                              @"languages": @[ @{ @"code": @"", @"is_enabled": @NO } ],
                              @"mt_enabled": @NO,
                              @"name": @"",
                              @"postedit_enabled": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id"]
                                                       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}}/continuous_projects/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id",
  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([
    'analytics_enabled' => null,
    'auto_start_postedit' => null,
    'is_enabled' => null,
    'languages' => [
        [
                'code' => '',
                'is_enabled' => null
        ]
    ],
    'mt_enabled' => null,
    'name' => '',
    'postedit_enabled' => 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}}/continuous_projects/:id', [
  'body' => '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "is_enabled": false,
  "languages": [
    {
      "code": "",
      "is_enabled": false
    }
  ],
  "mt_enabled": false,
  "name": "",
  "postedit_enabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'analytics_enabled' => null,
  'auto_start_postedit' => null,
  'is_enabled' => null,
  'languages' => [
    [
        'code' => '',
        'is_enabled' => null
    ]
  ],
  'mt_enabled' => null,
  'name' => '',
  'postedit_enabled' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'analytics_enabled' => null,
  'auto_start_postedit' => null,
  'is_enabled' => null,
  'languages' => [
    [
        'code' => '',
        'is_enabled' => null
    ]
  ],
  'mt_enabled' => null,
  'name' => '',
  'postedit_enabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id');
$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}}/continuous_projects/:id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "is_enabled": false,
  "languages": [
    {
      "code": "",
      "is_enabled": false
    }
  ],
  "mt_enabled": false,
  "name": "",
  "postedit_enabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "is_enabled": false,
  "languages": [
    {
      "code": "",
      "is_enabled": false
    }
  ],
  "mt_enabled": false,
  "name": "",
  "postedit_enabled": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/continuous_projects/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id"

payload = {
    "analytics_enabled": False,
    "auto_start_postedit": False,
    "is_enabled": False,
    "languages": [
        {
            "code": "",
            "is_enabled": False
        }
    ],
    "mt_enabled": False,
    "name": "",
    "postedit_enabled": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id"

payload <- "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": 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}}/continuous_projects/:id")

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  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": 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/continuous_projects/:id') do |req|
  req.body = "{\n  \"analytics_enabled\": false,\n  \"auto_start_postedit\": false,\n  \"is_enabled\": false,\n  \"languages\": [\n    {\n      \"code\": \"\",\n      \"is_enabled\": false\n    }\n  ],\n  \"mt_enabled\": false,\n  \"name\": \"\",\n  \"postedit_enabled\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id";

    let payload = json!({
        "analytics_enabled": false,
        "auto_start_postedit": false,
        "is_enabled": false,
        "languages": (
            json!({
                "code": "",
                "is_enabled": false
            })
        ),
        "mt_enabled": false,
        "name": "",
        "postedit_enabled": 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);
}

echo '{
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "is_enabled": false,
  "languages": [
    {
      "code": "",
      "is_enabled": false
    }
  ],
  "mt_enabled": false,
  "name": "",
  "postedit_enabled": false
}' |  \
  http POST {{baseUrl}}/continuous_projects/:id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "analytics_enabled": false,\n  "auto_start_postedit": false,\n  "is_enabled": false,\n  "languages": [\n    {\n      "code": "",\n      "is_enabled": false\n    }\n  ],\n  "mt_enabled": false,\n  "name": "",\n  "postedit_enabled": false\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "analytics_enabled": false,
  "auto_start_postedit": false,
  "is_enabled": false,
  "languages": [
    [
      "code": "",
      "is_enabled": false
    ]
  ],
  "mt_enabled": false,
  "name": "",
  "postedit_enabled": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/subscription");

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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/continuous_projects/:id/subscription" {:content-type :json
                                                                                :form-params {:downgrade []
                                                                                              :payment_method 0
                                                                                              :period_end ""
                                                                                              :plan_id ""
                                                                                              :plan_name ""
                                                                                              :price ""
                                                                                              :products []
                                                                                              :schedule_name ""
                                                                                              :schedule_start ""
                                                                                              :subscription_id ""
                                                                                              :upgrade []
                                                                                              :withTrial ""}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/subscription"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription"),
    Content = new StringContent("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/subscription"

	payload := strings.NewReader("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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/continuous_projects/:id/subscription HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 241

{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/continuous_projects/:id/subscription")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/subscription"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/continuous_projects/:id/subscription")
  .header("content-type", "application/json")
  .body("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/continuous_projects/:id/subscription');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/continuous_projects/:id/subscription',
  headers: {'content-type': 'application/json'},
  data: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/subscription';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/subscription',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "downgrade": [],\n  "payment_method": 0,\n  "period_end": "",\n  "plan_id": "",\n  "plan_name": "",\n  "price": "",\n  "products": [],\n  "schedule_name": "",\n  "schedule_start": "",\n  "subscription_id": "",\n  "upgrade": [],\n  "withTrial": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription")
  .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/continuous_projects/:id/subscription',
  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({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/continuous_projects/:id/subscription',
  headers: {'content-type': 'application/json'},
  body: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  },
  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}}/continuous_projects/:id/subscription');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
});

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}}/continuous_projects/:id/subscription',
  headers: {'content-type': 'application/json'},
  data: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/subscription';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""}'
};

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 = @{ @"downgrade": @[  ],
                              @"payment_method": @0,
                              @"period_end": @"",
                              @"plan_id": @"",
                              @"plan_name": @"",
                              @"price": @"",
                              @"products": @[  ],
                              @"schedule_name": @"",
                              @"schedule_start": @"",
                              @"subscription_id": @"",
                              @"upgrade": @[  ],
                              @"withTrial": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/subscription"]
                                                       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}}/continuous_projects/:id/subscription" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/subscription",
  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([
    'downgrade' => [
        
    ],
    'payment_method' => 0,
    'period_end' => '',
    'plan_id' => '',
    'plan_name' => '',
    'price' => '',
    'products' => [
        
    ],
    'schedule_name' => '',
    'schedule_start' => '',
    'subscription_id' => '',
    'upgrade' => [
        
    ],
    'withTrial' => ''
  ]),
  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}}/continuous_projects/:id/subscription', [
  'body' => '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/subscription');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'downgrade' => [
    
  ],
  'payment_method' => 0,
  'period_end' => '',
  'plan_id' => '',
  'plan_name' => '',
  'price' => '',
  'products' => [
    
  ],
  'schedule_name' => '',
  'schedule_start' => '',
  'subscription_id' => '',
  'upgrade' => [
    
  ],
  'withTrial' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'downgrade' => [
    
  ],
  'payment_method' => 0,
  'period_end' => '',
  'plan_id' => '',
  'plan_name' => '',
  'price' => '',
  'products' => [
    
  ],
  'schedule_name' => '',
  'schedule_start' => '',
  'subscription_id' => '',
  'upgrade' => [
    
  ],
  'withTrial' => ''
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id/subscription');
$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}}/continuous_projects/:id/subscription' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/subscription' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/continuous_projects/:id/subscription", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/subscription"

payload = {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/subscription"

payload <- "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription")

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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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/continuous_projects/:id/subscription') do |req|
  req.body = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription";

    let payload = json!({
        "downgrade": (),
        "payment_method": 0,
        "period_end": "",
        "plan_id": "",
        "plan_name": "",
        "price": "",
        "products": (),
        "schedule_name": "",
        "schedule_start": "",
        "subscription_id": "",
        "upgrade": (),
        "withTrial": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}' |  \
  http PUT {{baseUrl}}/continuous_projects/:id/subscription \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "downgrade": [],\n  "payment_method": 0,\n  "period_end": "",\n  "plan_id": "",\n  "plan_name": "",\n  "price": "",\n  "products": [],\n  "schedule_name": "",\n  "schedule_start": "",\n  "subscription_id": "",\n  "upgrade": [],\n  "withTrial": ""\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/subscription

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/subscription")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id/subscription/payment");

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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/continuous_projects/:id/subscription/payment" {:content-type :json
                                                                                        :form-params {:downgrade []
                                                                                                      :payment_method 0
                                                                                                      :period_end ""
                                                                                                      :plan_id ""
                                                                                                      :plan_name ""
                                                                                                      :price ""
                                                                                                      :products []
                                                                                                      :schedule_name ""
                                                                                                      :schedule_start ""
                                                                                                      :subscription_id ""
                                                                                                      :upgrade []
                                                                                                      :withTrial ""}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:id/subscription/payment"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription/payment"),
    Content = new StringContent("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription/payment");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:id/subscription/payment"

	payload := strings.NewReader("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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/continuous_projects/:id/subscription/payment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 241

{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/continuous_projects/:id/subscription/payment")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:id/subscription/payment"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription/payment")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/continuous_projects/:id/subscription/payment")
  .header("content-type", "application/json")
  .body("{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/continuous_projects/:id/subscription/payment');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/continuous_projects/:id/subscription/payment',
  headers: {'content-type': 'application/json'},
  data: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:id/subscription/payment';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/continuous_projects/:id/subscription/payment',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "downgrade": [],\n  "payment_method": 0,\n  "period_end": "",\n  "plan_id": "",\n  "plan_name": "",\n  "price": "",\n  "products": [],\n  "schedule_name": "",\n  "schedule_start": "",\n  "subscription_id": "",\n  "upgrade": [],\n  "withTrial": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id/subscription/payment")
  .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/continuous_projects/:id/subscription/payment',
  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({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/continuous_projects/:id/subscription/payment',
  headers: {'content-type': 'application/json'},
  body: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  },
  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}}/continuous_projects/:id/subscription/payment');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  downgrade: [],
  payment_method: 0,
  period_end: '',
  plan_id: '',
  plan_name: '',
  price: '',
  products: [],
  schedule_name: '',
  schedule_start: '',
  subscription_id: '',
  upgrade: [],
  withTrial: ''
});

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}}/continuous_projects/:id/subscription/payment',
  headers: {'content-type': 'application/json'},
  data: {
    downgrade: [],
    payment_method: 0,
    period_end: '',
    plan_id: '',
    plan_name: '',
    price: '',
    products: [],
    schedule_name: '',
    schedule_start: '',
    subscription_id: '',
    upgrade: [],
    withTrial: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:id/subscription/payment';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"downgrade":[],"payment_method":0,"period_end":"","plan_id":"","plan_name":"","price":"","products":[],"schedule_name":"","schedule_start":"","subscription_id":"","upgrade":[],"withTrial":""}'
};

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 = @{ @"downgrade": @[  ],
                              @"payment_method": @0,
                              @"period_end": @"",
                              @"plan_id": @"",
                              @"plan_name": @"",
                              @"price": @"",
                              @"products": @[  ],
                              @"schedule_name": @"",
                              @"schedule_start": @"",
                              @"subscription_id": @"",
                              @"upgrade": @[  ],
                              @"withTrial": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:id/subscription/payment"]
                                                       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}}/continuous_projects/:id/subscription/payment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:id/subscription/payment",
  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([
    'downgrade' => [
        
    ],
    'payment_method' => 0,
    'period_end' => '',
    'plan_id' => '',
    'plan_name' => '',
    'price' => '',
    'products' => [
        
    ],
    'schedule_name' => '',
    'schedule_start' => '',
    'subscription_id' => '',
    'upgrade' => [
        
    ],
    'withTrial' => ''
  ]),
  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}}/continuous_projects/:id/subscription/payment', [
  'body' => '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id/subscription/payment');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'downgrade' => [
    
  ],
  'payment_method' => 0,
  'period_end' => '',
  'plan_id' => '',
  'plan_name' => '',
  'price' => '',
  'products' => [
    
  ],
  'schedule_name' => '',
  'schedule_start' => '',
  'subscription_id' => '',
  'upgrade' => [
    
  ],
  'withTrial' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'downgrade' => [
    
  ],
  'payment_method' => 0,
  'period_end' => '',
  'plan_id' => '',
  'plan_name' => '',
  'price' => '',
  'products' => [
    
  ],
  'schedule_name' => '',
  'schedule_start' => '',
  'subscription_id' => '',
  'upgrade' => [
    
  ],
  'withTrial' => ''
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:id/subscription/payment');
$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}}/continuous_projects/:id/subscription/payment' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id/subscription/payment' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/continuous_projects/:id/subscription/payment", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id/subscription/payment"

payload = {
    "downgrade": [],
    "payment_method": 0,
    "period_end": "",
    "plan_id": "",
    "plan_name": "",
    "price": "",
    "products": [],
    "schedule_name": "",
    "schedule_start": "",
    "subscription_id": "",
    "upgrade": [],
    "withTrial": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id/subscription/payment"

payload <- "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription/payment")

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  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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/continuous_projects/:id/subscription/payment') do |req|
  req.body = "{\n  \"downgrade\": [],\n  \"payment_method\": 0,\n  \"period_end\": \"\",\n  \"plan_id\": \"\",\n  \"plan_name\": \"\",\n  \"price\": \"\",\n  \"products\": [],\n  \"schedule_name\": \"\",\n  \"schedule_start\": \"\",\n  \"subscription_id\": \"\",\n  \"upgrade\": [],\n  \"withTrial\": \"\"\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}}/continuous_projects/:id/subscription/payment";

    let payload = json!({
        "downgrade": (),
        "payment_method": 0,
        "period_end": "",
        "plan_id": "",
        "plan_name": "",
        "price": "",
        "products": (),
        "schedule_name": "",
        "schedule_start": "",
        "subscription_id": "",
        "upgrade": (),
        "withTrial": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
}' |  \
  http PUT {{baseUrl}}/continuous_projects/:id/subscription/payment \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "downgrade": [],\n  "payment_method": 0,\n  "period_end": "",\n  "plan_id": "",\n  "plan_name": "",\n  "price": "",\n  "products": [],\n  "schedule_name": "",\n  "schedule_start": "",\n  "subscription_id": "",\n  "upgrade": [],\n  "withTrial": ""\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id/subscription/payment

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "downgrade": [],
  "payment_method": 0,
  "period_end": "",
  "plan_id": "",
  "plan_name": "",
  "price": "",
  "products": [],
  "schedule_name": "",
  "schedule_start": "",
  "subscription_id": "",
  "upgrade": [],
  "withTrial": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id/subscription/payment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId");

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  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId" {:content-type :json
                                                                                                 :form-params {:document {:data ""
                                                                                                                          :name ""}}})

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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}}/continuous_projects/:projectId/documents/:documentId"),
    Content = new StringContent("{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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}}/continuous_projects/:projectId/documents/:documentId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"

	payload := strings.NewReader("{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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/continuous_projects/:projectId/documents/:documentId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "document": {
    "data": "",
    "name": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")
  .header("content-type", "application/json")
  .body("{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  document: {
    data: '',
    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}}/continuous_projects/:projectId/documents/:documentId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId',
  headers: {'content-type': 'application/json'},
  data: {document: {data: '', name: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"document":{"data":"","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}}/continuous_projects/:projectId/documents/:documentId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "document": {\n    "data": "",\n    "name": ""\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  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")
  .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/continuous_projects/:projectId/documents/:documentId',
  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({document: {data: '', name: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId',
  headers: {'content-type': 'application/json'},
  body: {document: {data: '', 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}}/continuous_projects/:projectId/documents/:documentId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  document: {
    data: '',
    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}}/continuous_projects/:projectId/documents/:documentId',
  headers: {'content-type': 'application/json'},
  data: {document: {data: '', name: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"document":{"data":"","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 = @{ @"document": @{ @"data": @"", @"name": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"]
                                                       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}}/continuous_projects/:projectId/documents/:documentId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId",
  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([
    'document' => [
        'data' => '',
        '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}}/continuous_projects/:projectId/documents/:documentId', [
  'body' => '{
  "document": {
    "data": "",
    "name": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/documents/:documentId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'document' => [
    'data' => '',
    'name' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'document' => [
    'data' => '',
    'name' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/documents/:documentId');
$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}}/continuous_projects/:projectId/documents/:documentId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "document": {
    "data": "",
    "name": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "document": {
    "data": "",
    "name": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/continuous_projects/:projectId/documents/:documentId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"

payload = { "document": {
        "data": "",
        "name": ""
    } }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"

payload <- "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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}}/continuous_projects/:projectId/documents/:documentId")

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  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\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/continuous_projects/:projectId/documents/:documentId') do |req|
  req.body = "{\n  \"document\": {\n    \"data\": \"\",\n    \"name\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId";

    let payload = json!({"document": json!({
            "data": "",
            "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);
}

echo '{
  "document": {
    "data": "",
    "name": ""
  }
}' |  \
  http POST {{baseUrl}}/continuous_projects/:projectId/documents/:documentId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "document": {\n    "data": "",\n    "name": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/documents/:documentId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["document": [
    "data": "",
    "name": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/widgets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:projectId/widgets")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/widgets"

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}}/continuous_projects/:projectId/widgets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/widgets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/widgets"

	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/continuous_projects/:projectId/widgets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:projectId/widgets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/widgets"))
    .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}}/continuous_projects/:projectId/widgets")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:projectId/widgets")
  .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}}/continuous_projects/:projectId/widgets');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets';
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}}/continuous_projects/:projectId/widgets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/widgets',
  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}}/continuous_projects/:projectId/widgets'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:projectId/widgets');

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}}/continuous_projects/:projectId/widgets'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets';
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}}/continuous_projects/:projectId/widgets"]
                                                       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}}/continuous_projects/:projectId/widgets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/widgets",
  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}}/continuous_projects/:projectId/widgets');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/widgets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/widgets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:projectId/widgets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/widgets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/widgets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/widgets")

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/continuous_projects/:projectId/widgets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/widgets";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:projectId/widgets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/widgets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/widgets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"

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}}/continuous_projects/:projectId/documents/:documentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"

	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/continuous_projects/:projectId/documents/:documentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"))
    .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}}/continuous_projects/:projectId/documents/:documentId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")
  .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}}/continuous_projects/:projectId/documents/:documentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId';
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}}/continuous_projects/:projectId/documents/:documentId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/documents/:documentId',
  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}}/continuous_projects/:projectId/documents/:documentId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId');

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}}/continuous_projects/:projectId/documents/:documentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId';
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}}/continuous_projects/:projectId/documents/:documentId"]
                                                       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}}/continuous_projects/:projectId/documents/:documentId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId",
  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}}/continuous_projects/:projectId/documents/:documentId');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/documents/:documentId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/documents/:documentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/documents/:documentId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:projectId/documents/:documentId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")

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/continuous_projects/:projectId/documents/:documentId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:projectId/documents/:documentId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/documents/:documentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/documents/:documentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:id")

require "http/client"

url = "{{baseUrl}}/continuous_projects/: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}}/continuous_projects/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/: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/continuous_projects/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/: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}}/continuous_projects/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/: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}}/continuous_projects/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/continuous_projects/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/: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}}/continuous_projects/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/: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}}/continuous_projects/: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}}/continuous_projects/: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}}/continuous_projects/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/: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}}/continuous_projects/: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}}/continuous_projects/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/: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}}/continuous_projects/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/: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/continuous_projects/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

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}}/continuous_projects/:projectId/widgets/:widgetId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

	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/continuous_projects/:projectId/widgets/:widgetId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"))
    .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}}/continuous_projects/:projectId/widgets/:widgetId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .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}}/continuous_projects/:projectId/widgets/:widgetId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId';
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}}/continuous_projects/:projectId/widgets/:widgetId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/widgets/:widgetId',
  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}}/continuous_projects/:projectId/widgets/:widgetId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');

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}}/continuous_projects/:projectId/widgets/:widgetId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId';
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}}/continuous_projects/:projectId/widgets/:widgetId"]
                                                       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}}/continuous_projects/:projectId/widgets/:widgetId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId",
  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}}/continuous_projects/:projectId/widgets/:widgetId');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:projectId/widgets/:widgetId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")

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/continuous_projects/:projectId/widgets/:widgetId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/widgets/:widgetId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects/:projectId/documents");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects/:projectId/documents")

require "http/client"

url = "{{baseUrl}}/continuous_projects/:projectId/documents"

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}}/continuous_projects/:projectId/documents"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects/:projectId/documents");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects/:projectId/documents"

	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/continuous_projects/:projectId/documents HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects/:projectId/documents")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects/:projectId/documents"))
    .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}}/continuous_projects/:projectId/documents")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects/:projectId/documents")
  .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}}/continuous_projects/:projectId/documents');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/continuous_projects/:projectId/documents'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects/:projectId/documents';
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}}/continuous_projects/:projectId/documents',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects/:projectId/documents")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects/:projectId/documents',
  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}}/continuous_projects/:projectId/documents'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects/:projectId/documents');

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}}/continuous_projects/:projectId/documents'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects/:projectId/documents';
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}}/continuous_projects/:projectId/documents"]
                                                       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}}/continuous_projects/:projectId/documents" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects/:projectId/documents",
  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}}/continuous_projects/:projectId/documents');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects/:projectId/documents');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects/:projectId/documents');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects/:projectId/documents' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects/:projectId/documents' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects/:projectId/documents")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects/:projectId/documents"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects/:projectId/documents"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects/:projectId/documents")

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/continuous_projects/:projectId/documents') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects/:projectId/documents";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects/:projectId/documents

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects/:projectId/documents

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects/:projectId/documents")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continuous_projects");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/continuous_projects")

require "http/client"

url = "{{baseUrl}}/continuous_projects"

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}}/continuous_projects"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/continuous_projects");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/continuous_projects"

	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/continuous_projects HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continuous_projects")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/continuous_projects"))
    .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}}/continuous_projects")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/continuous_projects")
  .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}}/continuous_projects');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/continuous_projects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/continuous_projects';
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}}/continuous_projects',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/continuous_projects")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/continuous_projects',
  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}}/continuous_projects'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/continuous_projects');

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}}/continuous_projects'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/continuous_projects';
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}}/continuous_projects"]
                                                       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}}/continuous_projects" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/continuous_projects",
  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}}/continuous_projects');

echo $response->getBody();

setUrl('{{baseUrl}}/continuous_projects');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/continuous_projects');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/continuous_projects' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/continuous_projects' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/continuous_projects")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/continuous_projects"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/continuous_projects"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/continuous_projects")

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/continuous_projects') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/continuous_projects";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/continuous_projects

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/continuous_projects

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continuous_projects")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporates/:corporateId/user-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  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/corporates/:corporateId/user-groups" {:content-type :json
                                                                                :form-params {:corporate_id 0
                                                                                              :id 0
                                                                                              :name ""
                                                                                              :permissions []}})

require "http/client"

url = "{{baseUrl}}/corporates/:corporateId/user-groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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}}/corporates/:corporateId/user-groups"),
    Content = new StringContent("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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}}/corporates/:corporateId/user-groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporates/:corporateId/user-groups"

	payload := strings.NewReader("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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/corporates/:corporateId/user-groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/corporates/:corporateId/user-groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporates/:corporateId/user-groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/corporates/:corporateId/user-groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/corporates/:corporateId/user-groups")
  .header("content-type", "application/json")
  .body("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}")
  .asString();

const data = JSON.stringify({
  corporate_id: 0,
  id: 0,
  name: '',
  permissions: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/corporates/:corporateId/user-groups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/corporates/:corporateId/user-groups',
  headers: {'content-type': 'application/json'},
  data: {corporate_id: 0, id: 0, name: '', permissions: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporates/:corporateId/user-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"corporate_id":0,"id":0,"name":"","permissions":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/corporates/:corporateId/user-groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "corporate_id": 0,\n  "id": 0,\n  "name": "",\n  "permissions": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/corporates/:corporateId/user-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/corporates/:corporateId/user-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({corporate_id: 0, id: 0, name: '', permissions: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/corporates/:corporateId/user-groups',
  headers: {'content-type': 'application/json'},
  body: {corporate_id: 0, id: 0, name: '', permissions: []},
  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}}/corporates/:corporateId/user-groups');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  corporate_id: 0,
  id: 0,
  name: '',
  permissions: []
});

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}}/corporates/:corporateId/user-groups',
  headers: {'content-type': 'application/json'},
  data: {corporate_id: 0, id: 0, name: '', permissions: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporates/:corporateId/user-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"corporate_id":0,"id":0,"name":"","permissions":[]}'
};

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 = @{ @"corporate_id": @0,
                              @"id": @0,
                              @"name": @"",
                              @"permissions": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporates/:corporateId/user-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([
    'corporate_id' => 0,
    'id' => 0,
    'name' => '',
    'permissions' => [
        
    ]
  ]),
  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}}/corporates/:corporateId/user-groups', [
  'body' => '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/corporates/:corporateId/user-groups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'corporate_id' => 0,
  'id' => 0,
  'name' => '',
  'permissions' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'corporate_id' => 0,
  'id' => 0,
  'name' => '',
  'permissions' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporates/:corporateId/user-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/corporates/:corporateId/user-groups", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporates/:corporateId/user-groups"

payload = {
    "corporate_id": 0,
    "id": 0,
    "name": "",
    "permissions": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporates/:corporateId/user-groups"

payload <- "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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}}/corporates/:corporateId/user-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  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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/corporates/:corporateId/user-groups') do |req|
  req.body = "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporates/:corporateId/user-groups";

    let payload = json!({
        "corporate_id": 0,
        "id": 0,
        "name": "",
        "permissions": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}' |  \
  http POST {{baseUrl}}/corporates/:corporateId/user-groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "corporate_id": 0,\n  "id": 0,\n  "name": "",\n  "permissions": []\n}' \
  --output-document \
  - {{baseUrl}}/corporates/:corporateId/user-groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporates/:corporateId/user-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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporate/user-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  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/corporate/user-groups" {:content-type :json
                                                                  :form-params {:corporate_id 0
                                                                                :id 0
                                                                                :name ""
                                                                                :permissions []}})

require "http/client"

url = "{{baseUrl}}/corporate/user-groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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}}/corporate/user-groups"),
    Content = new StringContent("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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}}/corporate/user-groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporate/user-groups"

	payload := strings.NewReader("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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/corporate/user-groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/corporate/user-groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporate/user-groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/corporate/user-groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/corporate/user-groups")
  .header("content-type", "application/json")
  .body("{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}")
  .asString();

const data = JSON.stringify({
  corporate_id: 0,
  id: 0,
  name: '',
  permissions: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/corporate/user-groups');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/corporate/user-groups',
  headers: {'content-type': 'application/json'},
  data: {corporate_id: 0, id: 0, name: '', permissions: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporate/user-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"corporate_id":0,"id":0,"name":"","permissions":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/corporate/user-groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "corporate_id": 0,\n  "id": 0,\n  "name": "",\n  "permissions": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/corporate/user-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/corporate/user-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({corporate_id: 0, id: 0, name: '', permissions: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/corporate/user-groups',
  headers: {'content-type': 'application/json'},
  body: {corporate_id: 0, id: 0, name: '', permissions: []},
  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}}/corporate/user-groups');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  corporate_id: 0,
  id: 0,
  name: '',
  permissions: []
});

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}}/corporate/user-groups',
  headers: {'content-type': 'application/json'},
  data: {corporate_id: 0, id: 0, name: '', permissions: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporate/user-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"corporate_id":0,"id":0,"name":"","permissions":[]}'
};

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 = @{ @"corporate_id": @0,
                              @"id": @0,
                              @"name": @"",
                              @"permissions": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/corporate/user-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}}/corporate/user-groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporate/user-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([
    'corporate_id' => 0,
    'id' => 0,
    'name' => '',
    'permissions' => [
        
    ]
  ]),
  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}}/corporate/user-groups', [
  'body' => '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/corporate/user-groups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'corporate_id' => 0,
  'id' => 0,
  'name' => '',
  'permissions' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'corporate_id' => 0,
  'id' => 0,
  'name' => '',
  'permissions' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/corporate/user-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}}/corporate/user-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporate/user-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/corporate/user-groups", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporate/user-groups"

payload = {
    "corporate_id": 0,
    "id": 0,
    "name": "",
    "permissions": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporate/user-groups"

payload <- "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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}}/corporate/user-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  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\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/corporate/user-groups') do |req|
  req.body = "{\n  \"corporate_id\": 0,\n  \"id\": 0,\n  \"name\": \"\",\n  \"permissions\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporate/user-groups";

    let payload = json!({
        "corporate_id": 0,
        "id": 0,
        "name": "",
        "permissions": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
}' |  \
  http POST {{baseUrl}}/corporate/user-groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "corporate_id": 0,\n  "id": 0,\n  "name": "",\n  "permissions": []\n}' \
  --output-document \
  - {{baseUrl}}/corporate/user-groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "corporate_id": 0,
  "id": 0,
  "name": "",
  "permissions": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporate/user-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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporate/users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/corporate/users")

require "http/client"

url = "{{baseUrl}}/corporate/users"

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}}/corporate/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/corporate/users");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporate/users"

	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/corporate/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/corporate/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporate/users"))
    .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}}/corporate/users")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/corporate/users")
  .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}}/corporate/users');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/corporate/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporate/users';
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}}/corporate/users',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/corporate/users")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/corporate/users',
  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}}/corporate/users'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/corporate/users');

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}}/corporate/users'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporate/users';
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}}/corporate/users"]
                                                       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}}/corporate/users" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporate/users",
  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}}/corporate/users');

echo $response->getBody();

setUrl('{{baseUrl}}/corporate/users');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/corporate/users');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/corporate/users' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporate/users' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/corporate/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporate/users"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporate/users"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/corporate/users")

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/corporate/users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporate/users";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/corporate/users

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/corporate/users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporate/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporates/:corporateId/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/corporates/:corporateId/permissions")

require "http/client"

url = "{{baseUrl}}/corporates/:corporateId/permissions"

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}}/corporates/:corporateId/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/corporates/:corporateId/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporates/:corporateId/permissions"

	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/corporates/:corporateId/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/corporates/:corporateId/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporates/:corporateId/permissions"))
    .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}}/corporates/:corporateId/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/corporates/:corporateId/permissions")
  .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}}/corporates/:corporateId/permissions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/corporates/:corporateId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporates/:corporateId/permissions';
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}}/corporates/:corporateId/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/corporates/:corporateId/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/corporates/:corporateId/permissions',
  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}}/corporates/:corporateId/permissions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/corporates/:corporateId/permissions');

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}}/corporates/:corporateId/permissions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporates/:corporateId/permissions';
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}}/corporates/:corporateId/permissions"]
                                                       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}}/corporates/:corporateId/permissions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporates/:corporateId/permissions",
  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}}/corporates/:corporateId/permissions');

echo $response->getBody();

setUrl('{{baseUrl}}/corporates/:corporateId/permissions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/corporates/:corporateId/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/corporates/:corporateId/permissions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporates/:corporateId/permissions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/corporates/:corporateId/permissions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporates/:corporateId/permissions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporates/:corporateId/permissions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/corporates/:corporateId/permissions")

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/corporates/:corporateId/permissions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporates/:corporateId/permissions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/corporates/:corporateId/permissions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/corporates/:corporateId/permissions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporates/:corporateId/permissions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporates/all");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/corporates/all")

require "http/client"

url = "{{baseUrl}}/corporates/all"

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}}/corporates/all"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/corporates/all");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporates/all"

	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/corporates/all HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/corporates/all")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporates/all"))
    .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}}/corporates/all")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/corporates/all")
  .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}}/corporates/all');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/corporates/all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporates/all';
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}}/corporates/all',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/corporates/all")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/corporates/all',
  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}}/corporates/all'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/corporates/all');

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}}/corporates/all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporates/all';
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}}/corporates/all"]
                                                       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}}/corporates/all" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporates/all",
  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}}/corporates/all');

echo $response->getBody();

setUrl('{{baseUrl}}/corporates/all');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/corporates/all');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/corporates/all' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporates/all' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/corporates/all")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporates/all"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporates/all"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/corporates/all")

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/corporates/all') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporates/all";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/corporates/all

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/corporates/all

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporates/all")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporates/:corporateId/user-groups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/corporates/:corporateId/user-groups")

require "http/client"

url = "{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/corporates/:corporateId/user-groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporates/:corporateId/user-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/corporates/:corporateId/user-groups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/corporates/:corporateId/user-groups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/corporates/:corporateId/user-groups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/corporates/:corporateId/user-groups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/corporates/:corporateId/user-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}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporates/:corporateId/user-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}}/corporates/:corporateId/user-groups');

echo $response->getBody();

setUrl('{{baseUrl}}/corporates/:corporateId/user-groups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/corporates/:corporateId/user-groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/corporates/:corporateId/user-groups' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporates/:corporateId/user-groups' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/corporates/:corporateId/user-groups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporates/:corporateId/user-groups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporates/:corporateId/user-groups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/corporates/:corporateId/user-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/corporates/:corporateId/user-groups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporates/:corporateId/user-groups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/corporates/:corporateId/user-groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/corporates/:corporateId/user-groups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporates/:corporateId/user-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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporates/:corporateId/users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/corporates/:corporateId/users")

require "http/client"

url = "{{baseUrl}}/corporates/:corporateId/users"

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}}/corporates/:corporateId/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/corporates/:corporateId/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporates/:corporateId/users"

	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/corporates/:corporateId/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/corporates/:corporateId/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporates/:corporateId/users"))
    .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}}/corporates/:corporateId/users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/corporates/:corporateId/users")
  .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}}/corporates/:corporateId/users');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/corporates/:corporateId/users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporates/:corporateId/users';
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}}/corporates/:corporateId/users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/corporates/:corporateId/users")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/corporates/:corporateId/users',
  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}}/corporates/:corporateId/users'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/corporates/:corporateId/users');

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}}/corporates/:corporateId/users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporates/:corporateId/users';
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}}/corporates/:corporateId/users"]
                                                       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}}/corporates/:corporateId/users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporates/:corporateId/users",
  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}}/corporates/:corporateId/users');

echo $response->getBody();

setUrl('{{baseUrl}}/corporates/:corporateId/users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/corporates/:corporateId/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/corporates/:corporateId/users' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporates/:corporateId/users' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/corporates/:corporateId/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporates/:corporateId/users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporates/:corporateId/users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/corporates/:corporateId/users")

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/corporates/:corporateId/users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporates/:corporateId/users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/corporates/:corporateId/users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/corporates/:corporateId/users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporates/:corporateId/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporates/:corporateId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/corporates/:corporateId")

require "http/client"

url = "{{baseUrl}}/corporates/:corporateId"

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}}/corporates/:corporateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/corporates/:corporateId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporates/:corporateId"

	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/corporates/:corporateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/corporates/:corporateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporates/:corporateId"))
    .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}}/corporates/:corporateId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/corporates/:corporateId")
  .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}}/corporates/:corporateId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/corporates/:corporateId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporates/:corporateId';
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}}/corporates/:corporateId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/corporates/:corporateId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/corporates/:corporateId',
  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}}/corporates/:corporateId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/corporates/:corporateId');

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}}/corporates/:corporateId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporates/:corporateId';
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}}/corporates/:corporateId"]
                                                       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}}/corporates/:corporateId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/corporates/:corporateId",
  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}}/corporates/:corporateId');

echo $response->getBody();

setUrl('{{baseUrl}}/corporates/:corporateId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/corporates/:corporateId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/corporates/:corporateId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/corporates/:corporateId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/corporates/:corporateId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/corporates/:corporateId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/corporates/:corporateId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/corporates/:corporateId")

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/corporates/:corporateId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/corporates/:corporateId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/corporates/:corporateId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/corporates/:corporateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/corporates/:corporateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/corporate/permissions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/corporate/permissions")

require "http/client"

url = "{{baseUrl}}/corporate/permissions"

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}}/corporate/permissions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/corporate/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/corporate/permissions"

	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/corporate/permissions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/corporate/permissions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/corporate/permissions"))
    .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}}/corporate/permissions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/corporate/permissions")
  .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}}/corporate/permissions');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/corporate/permissions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/corporate/permissions';
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}}/corporate/permissions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/corporate/permissions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/corporate/permissions',
  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}}/corporate/permissions'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/corporate/permissions');

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}}/corporate/permissions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/corporate/permissions';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}