CURL *hnd = curl_easy_init();

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

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  \"jMXUw-BE_2vd\"\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/billing/actions/" {:content-type :json
                                                             :form-params ["jMXUw-BE_2vd"]})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/billing/actions/"

	payload := strings.NewReader("[\n  \"jMXUw-BE_2vd\"\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/billing/actions/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

[
  "jMXUw-BE_2vd"
]

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/billing/actions/")
  .header("content-type", "application/json")
  .body("[\n  \"jMXUw-BE_2vd\"\n]")
  .asString();

const data = JSON.stringify([
  'jMXUw-BE_2vd'
]);

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing/actions/',
  headers: {'content-type': 'application/json'},
  data: ['jMXUw-BE_2vd']
};

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

const url = '{{baseUrl}}/billing/actions/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["jMXUw-BE_2vd"]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing/actions/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  "jMXUw-BE_2vd"\n]'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing/actions/',
  headers: {'content-type': 'application/json'},
  body: ['jMXUw-BE_2vd'],
  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}}/billing/actions/');

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

req.type('json');
req.send([
  'jMXUw-BE_2vd'
]);

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}}/billing/actions/',
  headers: {'content-type': 'application/json'},
  data: ['jMXUw-BE_2vd']
};

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

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

const url = '{{baseUrl}}/billing/actions/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["jMXUw-BE_2vd"]'
};

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 = @[ @"jMXUw-BE_2vd" ];

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

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

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

 "{{baseUrl}}/billing/actions/",
  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([
    'jMXUw-BE_2vd'
  ]),
  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}}/billing/actions/', [
  'body' => '[
  "jMXUw-BE_2vd"
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing/actions/' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  "jMXUw-BE_2vd"
]'

import http.client

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

payload = "[\n  \"jMXUw-BE_2vd\"\n]"

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

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

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

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

import requests

url = "{{baseUrl}}/billing/actions/"

payload = ["jMXUw-BE_2vd"]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing/actions/"

payload <- "[\n  \"jMXUw-BE_2vd\"\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}}/billing/actions/")

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  \"jMXUw-BE_2vd\"\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/billing/actions/') do |req|
  req.body = "[\n  \"jMXUw-BE_2vd\"\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = ("jMXUw-BE_2vd");

    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 '[
  "jMXUw-BE_2vd"
]' |  \
  http POST {{baseUrl}}/billing/actions/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  "jMXUw-BE_2vd"\n]' \
  --output-document \
  - {{baseUrl}}/billing/actions/

import Foundation

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

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

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

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  \"jMXUw-BE_2vd\"\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/target-actions/" {:content-type :json
                                                            :form-params ["jMXUw-BE_2vd"]})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/target-actions/"

	payload := strings.NewReader("[\n  \"jMXUw-BE_2vd\"\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/target-actions/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

[
  "jMXUw-BE_2vd"
]

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/target-actions/")
  .header("content-type", "application/json")
  .body("[\n  \"jMXUw-BE_2vd\"\n]")
  .asString();

const data = JSON.stringify([
  'jMXUw-BE_2vd'
]);

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/target-actions/',
  headers: {'content-type': 'application/json'},
  data: ['jMXUw-BE_2vd']
};

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

const url = '{{baseUrl}}/target-actions/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["jMXUw-BE_2vd"]'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/target-actions/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  "jMXUw-BE_2vd"\n]'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/target-actions/',
  headers: {'content-type': 'application/json'},
  body: ['jMXUw-BE_2vd'],
  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}}/target-actions/');

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

req.type('json');
req.send([
  'jMXUw-BE_2vd'
]);

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}}/target-actions/',
  headers: {'content-type': 'application/json'},
  data: ['jMXUw-BE_2vd']
};

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

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

const url = '{{baseUrl}}/target-actions/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["jMXUw-BE_2vd"]'
};

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 = @[ @"jMXUw-BE_2vd" ];

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

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

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

 "{{baseUrl}}/target-actions/",
  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([
    'jMXUw-BE_2vd'
  ]),
  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}}/target-actions/', [
  'body' => '[
  "jMXUw-BE_2vd"
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/target-actions/' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  "jMXUw-BE_2vd"
]'

import http.client

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

payload = "[\n  \"jMXUw-BE_2vd\"\n]"

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

conn.request("POST", "/baseUrl/target-actions/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/target-actions/"

payload = ["jMXUw-BE_2vd"]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/target-actions/"

payload <- "[\n  \"jMXUw-BE_2vd\"\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}}/target-actions/")

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  \"jMXUw-BE_2vd\"\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/target-actions/') do |req|
  req.body = "[\n  \"jMXUw-BE_2vd\"\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = ("jMXUw-BE_2vd");

    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 '[
  "jMXUw-BE_2vd"
]' |  \
  http POST {{baseUrl}}/target-actions/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  "jMXUw-BE_2vd"\n]' \
  --output-document \
  - {{baseUrl}}/target-actions/

import Foundation

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

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

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

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  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/billing/estimate/" {:content-type :json
                                                              :form-params {:coupon_ids []
                                                                            :plan_id ""
                                                                            :target_ids []}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/billing/estimate/"

	payload := strings.NewReader("{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\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/billing/estimate/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/billing/estimate/")
  .header("content-type", "application/json")
  .body("{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}")
  .asString();

const data = JSON.stringify({
  coupon_ids: [],
  plan_id: '',
  target_ids: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing/estimate/',
  headers: {'content-type': 'application/json'},
  data: {coupon_ids: [], plan_id: '', target_ids: []}
};

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

const url = '{{baseUrl}}/billing/estimate/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"coupon_ids":[],"plan_id":"","target_ids":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing/estimate/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "coupon_ids": [],\n  "plan_id": "",\n  "target_ids": []\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing/estimate/',
  headers: {'content-type': 'application/json'},
  body: {coupon_ids: [], plan_id: '', target_ids: []},
  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}}/billing/estimate/');

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

req.type('json');
req.send({
  coupon_ids: [],
  plan_id: '',
  target_ids: []
});

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}}/billing/estimate/',
  headers: {'content-type': 'application/json'},
  data: {coupon_ids: [], plan_id: '', target_ids: []}
};

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

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

const url = '{{baseUrl}}/billing/estimate/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"coupon_ids":[],"plan_id":"","target_ids":[]}'
};

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 = @{ @"coupon_ids": @[  ],
                              @"plan_id": @"",
                              @"target_ids": @[  ] };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'coupon_ids' => [
    
  ],
  'plan_id' => '',
  'target_ids' => [
    
  ]
]));

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing/estimate/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
}'

import http.client

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

payload = "{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/billing/estimate/"

payload = {
    "coupon_ids": [],
    "plan_id": "",
    "target_ids": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing/estimate/"

payload <- "{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\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}}/billing/estimate/")

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  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\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/billing/estimate/') do |req|
  req.body = "{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "coupon_ids": (),
        "plan_id": "",
        "target_ids": ()
    });

    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 '{
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
}' |  \
  http POST {{baseUrl}}/billing/estimate/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "coupon_ids": [],\n  "plan_id": "",\n  "target_ids": []\n}' \
  --output-document \
  - {{baseUrl}}/billing/estimate/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/billing/estimate/")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/billing/");

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  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/billing/" {:content-type :json
                                                      :form-params {:address ""
                                                                    :city ""
                                                                    :country ""
                                                                    :email ""
                                                                    :first_name ""
                                                                    :last_name ""
                                                                    :other ""
                                                                    :reg_number ""
                                                                    :vat_number ""
                                                                    :zip ""}})

require "http/client"

url = "{{baseUrl}}/billing/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/billing/"),
    Content = new StringContent("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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}}/billing/");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}")

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

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

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

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

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

}

PATCH /baseUrl/billing/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 172

{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/billing/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/billing/"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/billing/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/billing/")
  .header("content-type", "application/json")
  .body("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  address: '',
  city: '',
  country: '',
  email: '',
  first_name: '',
  last_name: '',
  other: '',
  reg_number: '',
  vat_number: '',
  zip: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/billing/',
  headers: {'content-type': 'application/json'},
  data: {
    address: '',
    city: '',
    country: '',
    email: '',
    first_name: '',
    last_name: '',
    other: '',
    reg_number: '',
    vat_number: '',
    zip: ''
  }
};

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

const url = '{{baseUrl}}/billing/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"address":"","city":"","country":"","email":"","first_name":"","last_name":"","other":"","reg_number":"","vat_number":"","zip":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing/',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": "",\n  "city": "",\n  "country": "",\n  "email": "",\n  "first_name": "",\n  "last_name": "",\n  "other": "",\n  "reg_number": "",\n  "vat_number": "",\n  "zip": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/billing/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/billing/',
  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({
  address: '',
  city: '',
  country: '',
  email: '',
  first_name: '',
  last_name: '',
  other: '',
  reg_number: '',
  vat_number: '',
  zip: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/billing/',
  headers: {'content-type': 'application/json'},
  body: {
    address: '',
    city: '',
    country: '',
    email: '',
    first_name: '',
    last_name: '',
    other: '',
    reg_number: '',
    vat_number: '',
    zip: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/billing/');

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

req.type('json');
req.send({
  address: '',
  city: '',
  country: '',
  email: '',
  first_name: '',
  last_name: '',
  other: '',
  reg_number: '',
  vat_number: '',
  zip: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/billing/',
  headers: {'content-type': 'application/json'},
  data: {
    address: '',
    city: '',
    country: '',
    email: '',
    first_name: '',
    last_name: '',
    other: '',
    reg_number: '',
    vat_number: '',
    zip: ''
  }
};

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

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

const url = '{{baseUrl}}/billing/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"address":"","city":"","country":"","email":"","first_name":"","last_name":"","other":"","reg_number":"","vat_number":"","zip":""}'
};

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 = @{ @"address": @"",
                              @"city": @"",
                              @"country": @"",
                              @"email": @"",
                              @"first_name": @"",
                              @"last_name": @"",
                              @"other": @"",
                              @"reg_number": @"",
                              @"vat_number": @"",
                              @"zip": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/billing/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/billing/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}" in

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

 "{{baseUrl}}/billing/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'address' => '',
    'city' => '',
    'country' => '',
    'email' => '',
    'first_name' => '',
    'last_name' => '',
    'other' => '',
    'reg_number' => '',
    'vat_number' => '',
    'zip' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/billing/', [
  'body' => '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/billing/');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => '',
  'city' => '',
  'country' => '',
  'email' => '',
  'first_name' => '',
  'last_name' => '',
  'other' => '',
  'reg_number' => '',
  'vat_number' => '',
  'zip' => ''
]));

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

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

append(json_encode([
  'address' => '',
  'city' => '',
  'country' => '',
  'email' => '',
  'first_name' => '',
  'last_name' => '',
  'other' => '',
  'reg_number' => '',
  'vat_number' => '',
  'zip' => ''
]));
$request->setRequestUrl('{{baseUrl}}/billing/');
$request->setRequestMethod('PATCH');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}'

import http.client

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

payload = "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/billing/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/billing/"

payload = {
    "address": "",
    "city": "",
    "country": "",
    "email": "",
    "first_name": "",
    "last_name": "",
    "other": "",
    "reg_number": "",
    "vat_number": "",
    "zip": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/billing/') do |req|
  req.body = "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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}}/billing/";

    let payload = json!({
        "address": "",
        "city": "",
        "country": "",
        "email": "",
        "first_name": "",
        "last_name": "",
        "other": "",
        "reg_number": "",
        "vat_number": "",
        "zip": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}' |  \
  http PATCH {{baseUrl}}/billing/ \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": "",\n  "city": "",\n  "country": "",\n  "email": "",\n  "first_name": "",\n  "last_name": "",\n  "other": "",\n  "reg_number": "",\n  "vat_number": "",\n  "zip": ""\n}' \
  --output-document \
  - {{baseUrl}}/billing/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/account/"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/account/"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/account/

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/billing/"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/billing/"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/billing/

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

import Foundation

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

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  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/billing/subscribe/" {:content-type :json
                                                               :form-params {:coupon_ids []
                                                                             :plan_id ""
                                                                             :target_ids []}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/billing/subscribe/"

	payload := strings.NewReader("{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\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/billing/subscribe/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
}

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

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/billing/subscribe/")
  .header("content-type", "application/json")
  .body("{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}")
  .asString();

const data = JSON.stringify({
  coupon_ids: [],
  plan_id: '',
  target_ids: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing/subscribe/',
  headers: {'content-type': 'application/json'},
  data: {coupon_ids: [], plan_id: '', target_ids: []}
};

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

const url = '{{baseUrl}}/billing/subscribe/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"coupon_ids":[],"plan_id":"","target_ids":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing/subscribe/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "coupon_ids": [],\n  "plan_id": "",\n  "target_ids": []\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing/subscribe/',
  headers: {'content-type': 'application/json'},
  body: {coupon_ids: [], plan_id: '', target_ids: []},
  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}}/billing/subscribe/');

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

req.type('json');
req.send({
  coupon_ids: [],
  plan_id: '',
  target_ids: []
});

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}}/billing/subscribe/',
  headers: {'content-type': 'application/json'},
  data: {coupon_ids: [], plan_id: '', target_ids: []}
};

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

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

const url = '{{baseUrl}}/billing/subscribe/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"coupon_ids":[],"plan_id":"","target_ids":[]}'
};

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 = @{ @"coupon_ids": @[  ],
                              @"plan_id": @"",
                              @"target_ids": @[  ] };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'coupon_ids' => [
    
  ],
  'plan_id' => '',
  'target_ids' => [
    
  ]
]));

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing/subscribe/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
}'

import http.client

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

payload = "{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/billing/subscribe/"

payload = {
    "coupon_ids": [],
    "plan_id": "",
    "target_ids": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing/subscribe/"

payload <- "{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\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}}/billing/subscribe/")

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  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\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/billing/subscribe/') do |req|
  req.body = "{\n  \"coupon_ids\": [],\n  \"plan_id\": \"\",\n  \"target_ids\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "coupon_ids": (),
        "plan_id": "",
        "target_ids": ()
    });

    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 '{
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
}' |  \
  http POST {{baseUrl}}/billing/subscribe/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "coupon_ids": [],\n  "plan_id": "",\n  "target_ids": []\n}' \
  --output-document \
  - {{baseUrl}}/billing/subscribe/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "coupon_ids": [],
  "plan_id": "",
  "target_ids": []
] as [String : Any]

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

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

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  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/billing/" {:content-type :json
                                                    :form-params {:address ""
                                                                  :city ""
                                                                  :country ""
                                                                  :email ""
                                                                  :first_name ""
                                                                  :last_name ""
                                                                  :other ""
                                                                  :reg_number ""
                                                                  :vat_number ""
                                                                  :zip ""}})

require "http/client"

url = "{{baseUrl}}/billing/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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}}/billing/"),
    Content = new StringContent("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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}}/billing/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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/billing/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 172

{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/billing/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/billing/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/billing/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/billing/")
  .header("content-type", "application/json")
  .body("{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  address: '',
  city: '',
  country: '',
  email: '',
  first_name: '',
  last_name: '',
  other: '',
  reg_number: '',
  vat_number: '',
  zip: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/billing/',
  headers: {'content-type': 'application/json'},
  data: {
    address: '',
    city: '',
    country: '',
    email: '',
    first_name: '',
    last_name: '',
    other: '',
    reg_number: '',
    vat_number: '',
    zip: ''
  }
};

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

const url = '{{baseUrl}}/billing/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"address":"","city":"","country":"","email":"","first_name":"","last_name":"","other":"","reg_number":"","vat_number":"","zip":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/billing/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": "",\n  "city": "",\n  "country": "",\n  "email": "",\n  "first_name": "",\n  "last_name": "",\n  "other": "",\n  "reg_number": "",\n  "vat_number": "",\n  "zip": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/billing/")
  .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/billing/',
  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({
  address: '',
  city: '',
  country: '',
  email: '',
  first_name: '',
  last_name: '',
  other: '',
  reg_number: '',
  vat_number: '',
  zip: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/billing/',
  headers: {'content-type': 'application/json'},
  body: {
    address: '',
    city: '',
    country: '',
    email: '',
    first_name: '',
    last_name: '',
    other: '',
    reg_number: '',
    vat_number: '',
    zip: ''
  },
  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}}/billing/');

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

req.type('json');
req.send({
  address: '',
  city: '',
  country: '',
  email: '',
  first_name: '',
  last_name: '',
  other: '',
  reg_number: '',
  vat_number: '',
  zip: ''
});

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}}/billing/',
  headers: {'content-type': 'application/json'},
  data: {
    address: '',
    city: '',
    country: '',
    email: '',
    first_name: '',
    last_name: '',
    other: '',
    reg_number: '',
    vat_number: '',
    zip: ''
  }
};

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

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

const url = '{{baseUrl}}/billing/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"address":"","city":"","country":"","email":"","first_name":"","last_name":"","other":"","reg_number":"","vat_number":"","zip":""}'
};

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 = @{ @"address": @"",
                              @"city": @"",
                              @"country": @"",
                              @"email": @"",
                              @"first_name": @"",
                              @"last_name": @"",
                              @"other": @"",
                              @"reg_number": @"",
                              @"vat_number": @"",
                              @"zip": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/billing/"]
                                                       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}}/billing/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}" in

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

 "{{baseUrl}}/billing/",
  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([
    'address' => '',
    'city' => '',
    'country' => '',
    'email' => '',
    'first_name' => '',
    'last_name' => '',
    'other' => '',
    'reg_number' => '',
    'vat_number' => '',
    'zip' => ''
  ]),
  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}}/billing/', [
  'body' => '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => '',
  'city' => '',
  'country' => '',
  'email' => '',
  'first_name' => '',
  'last_name' => '',
  'other' => '',
  'reg_number' => '',
  'vat_number' => '',
  'zip' => ''
]));

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

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

append(json_encode([
  'address' => '',
  'city' => '',
  'country' => '',
  'email' => '',
  'first_name' => '',
  'last_name' => '',
  'other' => '',
  'reg_number' => '',
  'vat_number' => '',
  'zip' => ''
]));
$request->setRequestUrl('{{baseUrl}}/billing/');
$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}}/billing/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}'

import http.client

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

payload = "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/billing/"

payload = {
    "address": "",
    "city": "",
    "country": "",
    "email": "",
    "first_name": "",
    "last_name": "",
    "other": "",
    "reg_number": "",
    "vat_number": "",
    "zip": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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}}/billing/")

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  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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/billing/') do |req|
  req.body = "{\n  \"address\": \"\",\n  \"city\": \"\",\n  \"country\": \"\",\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"last_name\": \"\",\n  \"other\": \"\",\n  \"reg_number\": \"\",\n  \"vat_number\": \"\",\n  \"zip\": \"\"\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}}/billing/";

    let payload = json!({
        "address": "",
        "city": "",
        "country": "",
        "email": "",
        "first_name": "",
        "last_name": "",
        "other": "",
        "reg_number": "",
        "vat_number": "",
        "zip": ""
    });

    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 '{
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
}' |  \
  http PUT {{baseUrl}}/billing/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": "",\n  "city": "",\n  "country": "",\n  "email": "",\n  "first_name": "",\n  "last_name": "",\n  "other": "",\n  "reg_number": "",\n  "vat_number": "",\n  "zip": ""\n}' \
  --output-document \
  - {{baseUrl}}/billing/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": "",
  "city": "",
  "country": "",
  "email": "",
  "first_name": "",
  "last_name": "",
  "other": "",
  "reg_number": "",
  "vat_number": "",
  "zip": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/keys/" {:content-type :json
                                                  :form-params {:id ""
                                                                :key ""
                                                                :name ""}})

require "http/client"

url = "{{baseUrl}}/keys/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/keys/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/keys/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "id": "",
  "key": "",
  "name": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/keys/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/keys/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","key":"","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}}/keys/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "key": "",\n  "name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/keys/")
  .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/keys/',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({id: '', key: '', name: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  id: '',
  key: '',
  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}}/keys/',
  headers: {'content-type': 'application/json'},
  data: {id: '', key: '', name: ''}
};

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

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

const url = '{{baseUrl}}/keys/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","key":"","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 = @{ @"id": @"",
                              @"key": @"",
                              @"name": @"" };

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/keys/"

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

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

print(response.json())

library(httr)

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

payload <- "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/keys/') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": "",
        "key": "",
        "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 '{
  "id": "",
  "key": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/keys/ \
  content-type:application/json

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

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/targets/:target_id/keys/" {:content-type :json
                                                                     :form-params {:id ""
                                                                                   :key ""
                                                                                   :name ""}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/keys/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/keys/"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/keys/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/keys/"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/targets/:target_id/keys/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "id": "",
  "key": "",
  "name": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/keys/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/keys/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/targets/:target_id/keys/")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  key: '',
  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}}/targets/:target_id/keys/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/keys/',
  headers: {'content-type': 'application/json'},
  data: {id: '', key: '', name: ''}
};

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

const url = '{{baseUrl}}/targets/:target_id/keys/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","key":"","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}}/targets/:target_id/keys/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "key": "",\n  "name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/keys/")
  .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/targets/:target_id/keys/',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({id: '', key: '', name: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  id: '',
  key: '',
  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}}/targets/:target_id/keys/',
  headers: {'content-type': 'application/json'},
  data: {id: '', key: '', name: ''}
};

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

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

const url = '{{baseUrl}}/targets/:target_id/keys/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","key":"","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 = @{ @"id": @"",
                              @"key": @"",
                              @"name": @"" };

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

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

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

 "{{baseUrl}}/targets/:target_id/keys/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => '',
    'key' => '',
    '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}}/targets/:target_id/keys/', [
  'body' => '{
  "id": "",
  "key": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/keys/');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'id' => '',
  'key' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/keys/');
$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}}/targets/:target_id/keys/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "key": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/keys/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "key": "",
  "name": ""
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

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

conn.request("POST", "/baseUrl/targets/:target_id/keys/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/keys/"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/keys/"

payload <- "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/keys/")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/targets/:target_id/keys/') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"key\": \"\",\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": "",
        "key": "",
        "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 '{
  "id": "",
  "key": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/targets/:target_id/keys/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "key": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/keys/

import Foundation

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/keys/:id/")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/keys/: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/keys/:id/ HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/keys/: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/keys/: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}}/keys/: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}}/keys/: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}}/keys/:id/'};

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

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

const url = '{{baseUrl}}/keys/: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}}/keys/: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}}/keys/:id/" in

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

 "{{baseUrl}}/keys/: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}}/keys/:id/');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/keys/:id/' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/keys/:id/' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/keys/:id/")

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

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

import requests

url = "{{baseUrl}}/keys/:id/"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/keys/:id/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/keys/: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/keys/: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}}/keys/: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}}/keys/:id/

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/keys/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/keys/: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}}/targets/:target_id/keys/:id/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/targets/:target_id/keys/:id/")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/targets/:target_id/keys/:id/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/keys/: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/targets/:target_id/keys/:id/ HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/targets/:target_id/keys/:id/'
};

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

const url = '{{baseUrl}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/keys/: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/targets/:target_id/keys/: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}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/'
};

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

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

const url = '{{baseUrl}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/" in

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

 "{{baseUrl}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/keys/:id/');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/targets/:target_id/keys/:id/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/keys/:id/' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/keys/:id/' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/targets/:target_id/keys/:id/")

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/keys/:id/"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/keys/:id/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/keys/: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/targets/:target_id/keys/: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}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/targets/:target_id/keys/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/keys/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/keys/"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/keys/"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/keys/

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/targets/:target_id/keys/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/keys/"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/keys/"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/targets/:target_id/keys/'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/keys/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/targets/:target_id/keys/');

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}}/targets/:target_id/keys/'};

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

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

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

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

 "{{baseUrl}}/targets/:target_id/keys/",
  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}}/targets/:target_id/keys/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/keys/');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/keys/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/keys/' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/targets/:target_id/keys/")

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/keys/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/keys/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/keys/")

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/targets/:target_id/keys/') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/targets/:target_id/keys/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/keys/

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/keys/:id/")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/keys/: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/keys/:id/ HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/keys/: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}}/keys/: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}}/keys/:id/" in

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

 "{{baseUrl}}/keys/: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}}/keys/:id/');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/keys/:id/")

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

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

import requests

url = "{{baseUrl}}/keys/:id/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/keys/:id/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/keys/: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/keys/:id/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/keys/: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}}/keys/:id/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/keys/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/keys/: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}}/targets/:target_id/keys/:id/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/targets/:target_id/keys/:id/")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/targets/:target_id/keys/:id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/keys/: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/targets/:target_id/keys/:id/ HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/targets/:target_id/keys/:id/'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/keys/:id/")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/" in

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

 "{{baseUrl}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/keys/:id/');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/targets/:target_id/keys/:id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/keys/:id/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/keys/:id/' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/targets/:target_id/keys/:id/")

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/keys/:id/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/keys/:id/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/keys/: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/targets/:target_id/keys/:id/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/keys/: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}}/targets/:target_id/keys/:id/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/keys/:id/

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/targets/activate/" {:content-type :json
                                                              :form-params [{}]})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/targets/activate/"

	payload := strings.NewReader("[\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/targets/activate/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/activate/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {}\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/activate/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/targets/activate/")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/activate/',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

const url = '{{baseUrl}}/targets/activate/';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send([
  {}
]);

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}}/targets/activate/',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

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

const url = '{{baseUrl}}/targets/activate/';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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 = @[ @{  } ];

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "[\n  {}\n]"

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

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

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

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

import requests

url = "{{baseUrl}}/targets/activate/"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/activate/"

payload <- "[\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}}/targets/activate/")

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  {}\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/targets/activate/') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = (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 '[
  {}
]' |  \
  http POST {{baseUrl}}/targets/activate/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/targets/activate/

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/targets/archive/" {:content-type :json
                                                             :form-params [{}]})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/targets/archive/"

	payload := strings.NewReader("[\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/targets/archive/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/archive/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {}\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/archive/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/targets/archive/")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/archive/',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

const url = '{{baseUrl}}/targets/archive/';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send([
  {}
]);

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}}/targets/archive/',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

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

const url = '{{baseUrl}}/targets/archive/';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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 = @[ @{  } ];

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "[\n  {}\n]"

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

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

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

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

import requests

url = "{{baseUrl}}/targets/archive/"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/archive/"

payload <- "[\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}}/targets/archive/")

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  {}\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/targets/archive/') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = (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 '[
  {}
]' |  \
  http POST {{baseUrl}}/targets/archive/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/targets/archive/

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "[\n  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/targets/archived/" {:content-type :json
                                                              :form-params [{}]})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/targets/archived/"

	payload := strings.NewReader("[\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/targets/archived/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/archived/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {}\n]"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "[\n  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/archived/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/targets/archived/")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/archived/',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

const url = '{{baseUrl}}/targets/archived/';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send([
  {}
]);

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}}/targets/archived/',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

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

const url = '{{baseUrl}}/targets/archived/';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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 = @[ @{  } ];

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "[\n  {}\n]"

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

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

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

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

import requests

url = "{{baseUrl}}/targets/archived/"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/archived/"

payload <- "[\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}}/targets/archived/")

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  {}\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/targets/archived/') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = (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 '[
  {}
]' |  \
  http POST {{baseUrl}}/targets/archived/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/targets/archived/

import Foundation

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

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

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

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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/targets/:target_id/assets/" {:content-type :json
                                                                       :form-params {:changed ""
                                                                                     :changed_by {:email ""
                                                                                                  :id ""
                                                                                                  :name ""}
                                                                                     :cookies [{:name ""
                                                                                                :value ""}]
                                                                                     :desc ""
                                                                                     :headers [{:name ""
                                                                                                :value ""}]
                                                                                     :host ""
                                                                                     :id ""
                                                                                     :include false
                                                                                     :name ""
                                                                                     :stack []
                                                                                     :verification_date ""
                                                                                     :verification_last_error ""
                                                                                     :verification_method ""
                                                                                     :verification_token ""
                                                                                     :verified false}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/assets/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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}}/targets/:target_id/assets/"),
    Content = new StringContent("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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}}/targets/:target_id/assets/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/assets/"

	payload := strings.NewReader("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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/targets/:target_id/assets/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 451

{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/targets/:target_id/assets/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/assets/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/targets/:target_id/assets/")
  .header("content-type", "application/json")
  .body("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
  .asString();

const data = JSON.stringify({
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  cookies: [
    {
      name: '',
      value: ''
    }
  ],
  desc: '',
  headers: [
    {
      name: '',
      value: ''
    }
  ],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: 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}}/targets/:target_id/assets/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/assets/',
  headers: {'content-type': 'application/json'},
  data: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: false
  }
};

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

const url = '{{baseUrl}}/targets/:target_id/assets/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"changed":"","changed_by":{"email":"","id":"","name":""},"cookies":[{"name":"","value":""}],"desc":"","headers":[{"name":"","value":""}],"host":"","id":"","include":false,"name":"","stack":[],"verification_date":"","verification_last_error":"","verification_method":"","verification_token":"","verified":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}}/targets/:target_id/assets/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "cookies": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "desc": "",\n  "headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "host": "",\n  "id": "",\n  "include": false,\n  "name": "",\n  "stack": [],\n  "verification_date": "",\n  "verification_last_error": "",\n  "verification_method": "",\n  "verification_token": "",\n  "verified": 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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/")
  .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/targets/:target_id/assets/',
  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({
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  cookies: [{name: '', value: ''}],
  desc: '',
  headers: [{name: '', value: ''}],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/assets/',
  headers: {'content-type': 'application/json'},
  body: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: 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}}/targets/:target_id/assets/');

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

req.type('json');
req.send({
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  cookies: [
    {
      name: '',
      value: ''
    }
  ],
  desc: '',
  headers: [
    {
      name: '',
      value: ''
    }
  ],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: 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}}/targets/:target_id/assets/',
  headers: {'content-type': 'application/json'},
  data: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: false
  }
};

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

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

const url = '{{baseUrl}}/targets/:target_id/assets/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"changed":"","changed_by":{"email":"","id":"","name":""},"cookies":[{"name":"","value":""}],"desc":"","headers":[{"name":"","value":""}],"host":"","id":"","include":false,"name":"","stack":[],"verification_date":"","verification_last_error":"","verification_method":"","verification_token":"","verified":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 = @{ @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"cookies": @[ @{ @"name": @"", @"value": @"" } ],
                              @"desc": @"",
                              @"headers": @[ @{ @"name": @"", @"value": @"" } ],
                              @"host": @"",
                              @"id": @"",
                              @"include": @NO,
                              @"name": @"",
                              @"stack": @[  ],
                              @"verification_date": @"",
                              @"verification_last_error": @"",
                              @"verification_method": @"",
                              @"verification_token": @"",
                              @"verified": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/assets/"]
                                                       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}}/targets/:target_id/assets/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}" in

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

 "{{baseUrl}}/targets/:target_id/assets/",
  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([
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'cookies' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'desc' => '',
    'headers' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'host' => '',
    'id' => '',
    'include' => null,
    'name' => '',
    'stack' => [
        
    ],
    'verification_date' => '',
    'verification_last_error' => '',
    'verification_method' => '',
    'verification_token' => '',
    'verified' => 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}}/targets/:target_id/assets/', [
  'body' => '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/assets/');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'cookies' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'desc' => '',
  'headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'host' => '',
  'id' => '',
  'include' => null,
  'name' => '',
  'stack' => [
    
  ],
  'verification_date' => '',
  'verification_last_error' => '',
  'verification_method' => '',
  'verification_token' => '',
  'verified' => null
]));

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

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

append(json_encode([
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'cookies' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'desc' => '',
  'headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'host' => '',
  'id' => '',
  'include' => null,
  'name' => '',
  'stack' => [
    
  ],
  'verification_date' => '',
  'verification_last_error' => '',
  'verification_method' => '',
  'verification_token' => '',
  'verified' => null
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/assets/');
$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}}/targets/:target_id/assets/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/assets/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}'

import http.client

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

payload = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

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

conn.request("POST", "/baseUrl/targets/:target_id/assets/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/assets/"

payload = {
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "cookies": [
        {
            "name": "",
            "value": ""
        }
    ],
    "desc": "",
    "headers": [
        {
            "name": "",
            "value": ""
        }
    ],
    "host": "",
    "id": "",
    "include": False,
    "name": "",
    "stack": [],
    "verification_date": "",
    "verification_last_error": "",
    "verification_method": "",
    "verification_token": "",
    "verified": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/assets/"

payload <- "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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}}/targets/:target_id/assets/")

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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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/targets/:target_id/assets/') do |req|
  req.body = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "cookies": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "desc": "",
        "headers": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "host": "",
        "id": "",
        "include": false,
        "name": "",
        "stack": (),
        "verification_date": "",
        "verification_last_error": "",
        "verification_method": "",
        "verification_token": "",
        "verified": 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 '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}' |  \
  http POST {{baseUrl}}/targets/:target_id/assets/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "cookies": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "desc": "",\n  "headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "host": "",\n  "id": "",\n  "include": false,\n  "name": "",\n  "stack": [],\n  "verification_date": "",\n  "verification_last_error": "",\n  "verification_method": "",\n  "verification_token": "",\n  "verified": false\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/assets/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "cookies": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "desc": "",
  "headers": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/targets/:target_id/assets/:id/")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/targets/:target_id/assets/:id/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/assets/: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/targets/:target_id/assets/:id/ HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/'
};

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

const url = '{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/: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/targets/:target_id/assets/: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}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/'
};

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

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

const url = '{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/" in

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

 "{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/targets/:target_id/assets/:id/")

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/assets/:id/"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/assets/:id/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/assets/: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/targets/:target_id/assets/: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}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/targets/:target_id/assets/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/assets/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/assets/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/targets/:target_id/assets/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/assets/"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/assets/"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/targets/:target_id/assets/'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/targets/:target_id/assets/');

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}}/targets/:target_id/assets/'};

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

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

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

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

 "{{baseUrl}}/targets/:target_id/assets/",
  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}}/targets/:target_id/assets/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/assets/');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/assets/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/assets/' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/targets/:target_id/assets/")

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/assets/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/assets/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/assets/")

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/targets/:target_id/assets/') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/targets/:target_id/assets/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/assets/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/assets/")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/assets/: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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/targets/:target_id/assets/:id/" {:content-type :json
                                                                            :form-params {:changed ""
                                                                                          :changed_by {:email ""
                                                                                                       :id ""
                                                                                                       :name ""}
                                                                                          :cookies [{:name ""
                                                                                                     :value ""}]
                                                                                          :desc ""
                                                                                          :headers [{:name ""
                                                                                                     :value ""}]
                                                                                          :host ""
                                                                                          :id ""
                                                                                          :include false
                                                                                          :name ""
                                                                                          :stack []
                                                                                          :verification_date ""
                                                                                          :verification_last_error ""
                                                                                          :verification_method ""
                                                                                          :verification_token ""
                                                                                          :verified false}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/assets/:id/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/assets/:id/"),
    Content = new StringContent("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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}}/targets/:target_id/assets/:id/");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/targets/:target_id/assets/:id/"

	payload := strings.NewReader("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")

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

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

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

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

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

}

PATCH /baseUrl/targets/:target_id/assets/:id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 451

{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/targets/:target_id/assets/:id/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/assets/:id/"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/:id/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/targets/:target_id/assets/:id/")
  .header("content-type", "application/json")
  .body("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
  .asString();

const data = JSON.stringify({
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  cookies: [
    {
      name: '',
      value: ''
    }
  ],
  desc: '',
  headers: [
    {
      name: '',
      value: ''
    }
  ],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: false
});

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

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

xhr.open('PATCH', '{{baseUrl}}/targets/:target_id/assets/:id/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: false
  }
};

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

const url = '{{baseUrl}}/targets/:target_id/assets/:id/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"changed":"","changed_by":{"email":"","id":"","name":""},"cookies":[{"name":"","value":""}],"desc":"","headers":[{"name":"","value":""}],"host":"","id":"","include":false,"name":"","stack":[],"verification_date":"","verification_last_error":"","verification_method":"","verification_token":"","verified":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}}/targets/:target_id/assets/:id/',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "cookies": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "desc": "",\n  "headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "host": "",\n  "id": "",\n  "include": false,\n  "name": "",\n  "stack": [],\n  "verification_date": "",\n  "verification_last_error": "",\n  "verification_method": "",\n  "verification_token": "",\n  "verified": 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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/:id/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/assets/: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({
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  cookies: [{name: '', value: ''}],
  desc: '',
  headers: [{name: '', value: ''}],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/',
  headers: {'content-type': 'application/json'},
  body: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: 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('PATCH', '{{baseUrl}}/targets/:target_id/assets/:id/');

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

req.type('json');
req.send({
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  cookies: [
    {
      name: '',
      value: ''
    }
  ],
  desc: '',
  headers: [
    {
      name: '',
      value: ''
    }
  ],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: 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: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: false
  }
};

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

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

const url = '{{baseUrl}}/targets/:target_id/assets/:id/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"changed":"","changed_by":{"email":"","id":"","name":""},"cookies":[{"name":"","value":""}],"desc":"","headers":[{"name":"","value":""}],"host":"","id":"","include":false,"name":"","stack":[],"verification_date":"","verification_last_error":"","verification_method":"","verification_token":"","verified":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 = @{ @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"cookies": @[ @{ @"name": @"", @"value": @"" } ],
                              @"desc": @"",
                              @"headers": @[ @{ @"name": @"", @"value": @"" } ],
                              @"host": @"",
                              @"id": @"",
                              @"include": @NO,
                              @"name": @"",
                              @"stack": @[  ],
                              @"verification_date": @"",
                              @"verification_last_error": @"",
                              @"verification_method": @"",
                              @"verification_token": @"",
                              @"verified": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/assets/:id/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/targets/:target_id/assets/:id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}" in

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

 "{{baseUrl}}/targets/:target_id/assets/:id/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'cookies' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'desc' => '',
    'headers' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'host' => '',
    'id' => '',
    'include' => null,
    'name' => '',
    'stack' => [
        
    ],
    'verification_date' => '',
    'verification_last_error' => '',
    'verification_method' => '',
    'verification_token' => '',
    'verified' => 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('PATCH', '{{baseUrl}}/targets/:target_id/assets/:id/', [
  'body' => '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'cookies' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'desc' => '',
  'headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'host' => '',
  'id' => '',
  'include' => null,
  'name' => '',
  'stack' => [
    
  ],
  'verification_date' => '',
  'verification_last_error' => '',
  'verification_method' => '',
  'verification_token' => '',
  'verified' => null
]));

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

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

append(json_encode([
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'cookies' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'desc' => '',
  'headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'host' => '',
  'id' => '',
  'include' => null,
  'name' => '',
  'stack' => [
    
  ],
  'verification_date' => '',
  'verification_last_error' => '',
  'verification_method' => '',
  'verification_token' => '',
  'verified' => null
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setRequestMethod('PATCH');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}'

import http.client

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

payload = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

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

conn.request("PATCH", "/baseUrl/targets/:target_id/assets/:id/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/targets/:target_id/assets/:id/"

payload = {
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "cookies": [
        {
            "name": "",
            "value": ""
        }
    ],
    "desc": "",
    "headers": [
        {
            "name": "",
            "value": ""
        }
    ],
    "host": "",
    "id": "",
    "include": False,
    "name": "",
    "stack": [],
    "verification_date": "",
    "verification_last_error": "",
    "verification_method": "",
    "verification_token": "",
    "verified": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/assets/:id/"

payload <- "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/assets/:id/")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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.patch('/baseUrl/targets/:target_id/assets/:id/') do |req|
  req.body = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "cookies": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "desc": "",
        "headers": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "host": "",
        "id": "",
        "include": false,
        "name": "",
        "stack": (),
        "verification_date": "",
        "verification_last_error": "",
        "verification_method": "",
        "verification_token": "",
        "verified": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}' |  \
  http PATCH {{baseUrl}}/targets/:target_id/assets/:id/ \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "cookies": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "desc": "",\n  "headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "host": "",\n  "id": "",\n  "include": false,\n  "name": "",\n  "stack": [],\n  "verification_date": "",\n  "verification_last_error": "",\n  "verification_method": "",\n  "verification_token": "",\n  "verified": false\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/assets/:id/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "cookies": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "desc": "",
  "headers": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/assets/:id/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/targets/:target_id/assets/:id/")

require "http/client"

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

var client = new RestClient("{{baseUrl}}/targets/:target_id/assets/:id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/assets/: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/targets/:target_id/assets/:id/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/targets/:target_id/assets/:id/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/:id/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/assets/: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}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/targets/:target_id/assets/:id/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/assets/:id/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/assets/:id/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/assets/: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/targets/:target_id/assets/:id/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/assets/: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}}/targets/:target_id/assets/:id/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/assets/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/assets/: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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/assets/: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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/targets/:target_id/assets/:id/" {:content-type :json
                                                                          :form-params {:changed ""
                                                                                        :changed_by {:email ""
                                                                                                     :id ""
                                                                                                     :name ""}
                                                                                        :cookies [{:name ""
                                                                                                   :value ""}]
                                                                                        :desc ""
                                                                                        :headers [{:name ""
                                                                                                   :value ""}]
                                                                                        :host ""
                                                                                        :id ""
                                                                                        :include false
                                                                                        :name ""
                                                                                        :stack []
                                                                                        :verification_date ""
                                                                                        :verification_last_error ""
                                                                                        :verification_method ""
                                                                                        :verification_token ""
                                                                                        :verified false}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/assets/:id/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/assets/:id/"),
    Content = new StringContent("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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}}/targets/:target_id/assets/:id/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/assets/:id/"

	payload := strings.NewReader("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/targets/:target_id/assets/:id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 451

{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/targets/:target_id/assets/:id/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/assets/:id/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": 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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/:id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/targets/:target_id/assets/:id/")
  .header("content-type", "application/json")
  .body("{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
  .asString();

const data = JSON.stringify({
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  cookies: [
    {
      name: '',
      value: ''
    }
  ],
  desc: '',
  headers: [
    {
      name: '',
      value: ''
    }
  ],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/targets/:target_id/assets/:id/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/assets/:id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"changed":"","changed_by":{"email":"","id":"","name":""},"cookies":[{"name":"","value":""}],"desc":"","headers":[{"name":"","value":""}],"host":"","id":"","include":false,"name":"","stack":[],"verification_date":"","verification_last_error":"","verification_method":"","verification_token":"","verified":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}}/targets/:target_id/assets/:id/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "cookies": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "desc": "",\n  "headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "host": "",\n  "id": "",\n  "include": false,\n  "name": "",\n  "stack": [],\n  "verification_date": "",\n  "verification_last_error": "",\n  "verification_method": "",\n  "verification_token": "",\n  "verified": 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  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/:id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/assets/: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({
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  cookies: [{name: '', value: ''}],
  desc: '',
  headers: [{name: '', value: ''}],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/',
  headers: {'content-type': 'application/json'},
  body: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/targets/:target_id/assets/:id/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  cookies: [
    {
      name: '',
      value: ''
    }
  ],
  desc: '',
  headers: [
    {
      name: '',
      value: ''
    }
  ],
  host: '',
  id: '',
  include: false,
  name: '',
  stack: [],
  verification_date: '',
  verification_last_error: '',
  verification_method: '',
  verification_token: '',
  verified: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    cookies: [{name: '', value: ''}],
    desc: '',
    headers: [{name: '', value: ''}],
    host: '',
    id: '',
    include: false,
    name: '',
    stack: [],
    verification_date: '',
    verification_last_error: '',
    verification_method: '',
    verification_token: '',
    verified: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/assets/:id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"changed":"","changed_by":{"email":"","id":"","name":""},"cookies":[{"name":"","value":""}],"desc":"","headers":[{"name":"","value":""}],"host":"","id":"","include":false,"name":"","stack":[],"verification_date":"","verification_last_error":"","verification_method":"","verification_token":"","verified":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 = @{ @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"cookies": @[ @{ @"name": @"", @"value": @"" } ],
                              @"desc": @"",
                              @"headers": @[ @{ @"name": @"", @"value": @"" } ],
                              @"host": @"",
                              @"id": @"",
                              @"include": @NO,
                              @"name": @"",
                              @"stack": @[  ],
                              @"verification_date": @"",
                              @"verification_last_error": @"",
                              @"verification_method": @"",
                              @"verification_token": @"",
                              @"verified": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/assets/:id/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/targets/:target_id/assets/:id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/assets/:id/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'cookies' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'desc' => '',
    'headers' => [
        [
                'name' => '',
                'value' => ''
        ]
    ],
    'host' => '',
    'id' => '',
    'include' => null,
    'name' => '',
    'stack' => [
        
    ],
    'verification_date' => '',
    'verification_last_error' => '',
    'verification_method' => '',
    'verification_token' => '',
    'verified' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/targets/:target_id/assets/:id/', [
  'body' => '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'cookies' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'desc' => '',
  'headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'host' => '',
  'id' => '',
  'include' => null,
  'name' => '',
  'stack' => [
    
  ],
  'verification_date' => '',
  'verification_last_error' => '',
  'verification_method' => '',
  'verification_token' => '',
  'verified' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'cookies' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'desc' => '',
  'headers' => [
    [
        'name' => '',
        'value' => ''
    ]
  ],
  'host' => '',
  'id' => '',
  'include' => null,
  'name' => '',
  'stack' => [
    
  ],
  'verification_date' => '',
  'verification_last_error' => '',
  'verification_method' => '',
  'verification_token' => '',
  'verified' => null
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/assets/:id/');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/assets/:id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/targets/:target_id/assets/:id/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/assets/:id/"

payload = {
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "cookies": [
        {
            "name": "",
            "value": ""
        }
    ],
    "desc": "",
    "headers": [
        {
            "name": "",
            "value": ""
        }
    ],
    "host": "",
    "id": "",
    "include": False,
    "name": "",
    "stack": [],
    "verification_date": "",
    "verification_last_error": "",
    "verification_method": "",
    "verification_token": "",
    "verified": False
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/assets/:id/"

payload <- "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/assets/:id/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/targets/:target_id/assets/:id/') do |req|
  req.body = "{\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"cookies\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"desc\": \"\",\n  \"headers\": [\n    {\n      \"name\": \"\",\n      \"value\": \"\"\n    }\n  ],\n  \"host\": \"\",\n  \"id\": \"\",\n  \"include\": false,\n  \"name\": \"\",\n  \"stack\": [],\n  \"verification_date\": \"\",\n  \"verification_last_error\": \"\",\n  \"verification_method\": \"\",\n  \"verification_token\": \"\",\n  \"verified\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/assets/:id/";

    let payload = json!({
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "cookies": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "desc": "",
        "headers": (
            json!({
                "name": "",
                "value": ""
            })
        ),
        "host": "",
        "id": "",
        "include": false,
        "name": "",
        "stack": (),
        "verification_date": "",
        "verification_last_error": "",
        "verification_method": "",
        "verification_token": "",
        "verified": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "cookies": [
    {
      "name": "",
      "value": ""
    }
  ],
  "desc": "",
  "headers": [
    {
      "name": "",
      "value": ""
    }
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
}' |  \
  http PUT {{baseUrl}}/targets/:target_id/assets/:id/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "cookies": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "desc": "",\n  "headers": [\n    {\n      "name": "",\n      "value": ""\n    }\n  ],\n  "host": "",\n  "id": "",\n  "include": false,\n  "name": "",\n  "stack": [],\n  "verification_date": "",\n  "verification_last_error": "",\n  "verification_method": "",\n  "verification_token": "",\n  "verified": false\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/assets/:id/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "cookies": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "desc": "",
  "headers": [
    [
      "name": "",
      "value": ""
    ]
  ],
  "host": "",
  "id": "",
  "include": false,
  "name": "",
  "stack": [],
  "verification_date": "",
  "verification_last_error": "",
  "verification_method": "",
  "verification_token": "",
  "verified": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/assets/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/assets/:id/verify/");

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  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/targets/:target_id/assets/:id/verify/" {:content-type :json
                                                                                  :form-params {:type ""}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/assets/:id/verify/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\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}}/targets/:target_id/assets/:id/verify/"),
    Content = new StringContent("{\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}}/targets/:target_id/assets/:id/verify/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/assets/:id/verify/"

	payload := strings.NewReader("{\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/targets/:target_id/assets/:id/verify/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/targets/:target_id/assets/:id/verify/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/assets/:id/verify/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\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  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/:id/verify/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/targets/:target_id/assets/:id/verify/")
  .header("content-type", "application/json")
  .body("{\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  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}}/targets/:target_id/assets/:id/verify/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/verify/',
  headers: {'content-type': 'application/json'},
  data: {type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/assets/:id/verify/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/targets/:target_id/assets/:id/verify/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\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  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/assets/:id/verify/")
  .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/targets/:target_id/assets/:id/verify/',
  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({type: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/assets/:id/verify/',
  headers: {'content-type': 'application/json'},
  body: {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}}/targets/:target_id/assets/:id/verify/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  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}}/targets/:target_id/assets/:id/verify/',
  headers: {'content-type': 'application/json'},
  data: {type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/assets/:id/verify/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/assets/:id/verify/"]
                                                       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}}/targets/:target_id/assets/:id/verify/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/assets/:id/verify/",
  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([
    '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}}/targets/:target_id/assets/:id/verify/', [
  'body' => '{
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/assets/:id/verify/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/assets/:id/verify/');
$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}}/targets/:target_id/assets/:id/verify/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/assets/:id/verify/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/targets/:target_id/assets/:id/verify/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/assets/:id/verify/"

payload = { "type": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/assets/:id/verify/"

payload <- "{\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}}/targets/:target_id/assets/:id/verify/")

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  \"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/targets/:target_id/assets/:id/verify/') do |req|
  req.body = "{\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}}/targets/:target_id/assets/:id/verify/";

    let payload = json!({"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 '{
  "type": ""
}' |  \
  http POST {{baseUrl}}/targets/:target_id/assets/:id/verify/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/assets/:id/verify/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["type": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/assets/:id/verify/")! 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}}/webhooks/");

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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/webhooks/" {:content-type :json
                                                      :form-params {:api_version ""
                                                                    :changed ""
                                                                    :changed_by {:email ""
                                                                                 :id ""
                                                                                 :name ""}
                                                                    :check_cert false
                                                                    :created ""
                                                                    :created_by {}
                                                                    :id ""
                                                                    :name ""
                                                                    :url ""}})

require "http/client"

url = "{{baseUrl}}/webhooks/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/webhooks/"),
    Content = new StringContent("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhooks/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/webhooks/"

	payload := strings.NewReader("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/webhooks/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/webhooks/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhooks/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/webhooks/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/webhooks/")
  .header("content-type", "application/json")
  .body("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/webhooks/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/webhooks/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/webhooks/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/webhooks/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/webhooks/")
  .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/webhooks/',
  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({
  api_version: '',
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/webhooks/',
  headers: {'content-type': 'application/json'},
  body: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/webhooks/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/webhooks/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhooks/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"api_version": @"",
                              @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"check_cert": @NO,
                              @"created": @"",
                              @"created_by": @{  },
                              @"id": @"",
                              @"name": @"",
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/webhooks/"]
                                                       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}}/webhooks/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/webhooks/",
  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([
    'api_version' => '',
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'check_cert' => null,
    'created' => '',
    'created_by' => [
        
    ],
    'id' => '',
    'name' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/webhooks/', [
  'body' => '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/webhooks/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/webhooks/');
$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}}/webhooks/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhooks/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/webhooks/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/webhooks/"

payload = {
    "api_version": "",
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "check_cert": False,
    "created": "",
    "created_by": {},
    "id": "",
    "name": "",
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhooks/"

payload <- "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhooks/")

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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/webhooks/') do |req|
  req.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/webhooks/";

    let payload = json!({
        "api_version": "",
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "check_cert": false,
        "created": "",
        "created_by": json!({}),
        "id": "",
        "name": "",
        "url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}' |  \
  http POST {{baseUrl}}/webhooks/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/webhooks/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "api_version": "",
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "check_cert": false,
  "created": "",
  "created_by": [],
  "id": "",
  "name": "",
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhooks/")! 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}}/targets/:target_id/webhooks/");

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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/targets/:target_id/webhooks/" {:content-type :json
                                                                         :form-params {:api_version ""
                                                                                       :changed ""
                                                                                       :changed_by {:email ""
                                                                                                    :id ""
                                                                                                    :name ""}
                                                                                       :check_cert false
                                                                                       :created ""
                                                                                       :created_by {}
                                                                                       :id ""
                                                                                       :name ""
                                                                                       :url ""}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/webhooks/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/webhooks/"),
    Content = new StringContent("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/webhooks/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/webhooks/"

	payload := strings.NewReader("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/targets/:target_id/webhooks/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/targets/:target_id/webhooks/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/webhooks/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/targets/:target_id/webhooks/")
  .header("content-type", "application/json")
  .body("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/targets/:target_id/webhooks/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/webhooks/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/webhooks/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/targets/:target_id/webhooks/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/")
  .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/targets/:target_id/webhooks/',
  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({
  api_version: '',
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/webhooks/',
  headers: {'content-type': 'application/json'},
  body: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/targets/:target_id/webhooks/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/webhooks/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/webhooks/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"api_version": @"",
                              @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"check_cert": @NO,
                              @"created": @"",
                              @"created_by": @{  },
                              @"id": @"",
                              @"name": @"",
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/webhooks/"]
                                                       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}}/targets/:target_id/webhooks/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/webhooks/",
  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([
    'api_version' => '',
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'check_cert' => null,
    'created' => '',
    'created_by' => [
        
    ],
    'id' => '',
    'name' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/targets/:target_id/webhooks/', [
  'body' => '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/webhooks/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/webhooks/');
$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}}/targets/:target_id/webhooks/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/webhooks/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/targets/:target_id/webhooks/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/webhooks/"

payload = {
    "api_version": "",
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "check_cert": False,
    "created": "",
    "created_by": {},
    "id": "",
    "name": "",
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/webhooks/"

payload <- "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/webhooks/")

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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/targets/:target_id/webhooks/') do |req|
  req.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/webhooks/";

    let payload = json!({
        "api_version": "",
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "check_cert": false,
        "created": "",
        "created_by": json!({}),
        "id": "",
        "name": "",
        "url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}' |  \
  http POST {{baseUrl}}/targets/:target_id/webhooks/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/webhooks/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "api_version": "",
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "check_cert": false,
  "created": "",
  "created_by": [],
  "id": "",
  "name": "",
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/webhooks/")! 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}}/webhooks/:id/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/webhooks/:id/")

require "http/client"

url = "{{baseUrl}}/webhooks/: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}}/webhooks/:id/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhooks/:id/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/webhooks/: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/webhooks/:id/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/webhooks/:id/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhooks/: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}}/webhooks/:id/")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/webhooks/: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}}/webhooks/:id/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/webhooks/:id/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/webhooks/: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}}/webhooks/:id/',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/webhooks/: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/webhooks/: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}}/webhooks/: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}}/webhooks/: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}}/webhooks/:id/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhooks/: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}}/webhooks/: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}}/webhooks/:id/" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/webhooks/: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}}/webhooks/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/webhooks/:id/');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/webhooks/:id/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhooks/:id/' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhooks/:id/' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/webhooks/:id/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/webhooks/:id/"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhooks/:id/"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhooks/: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/webhooks/: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}}/webhooks/: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}}/webhooks/:id/

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/webhooks/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhooks/: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}}/targets/:target_id/webhooks/:id/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/targets/:target_id/webhooks/:id/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/webhooks/:id/");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/webhooks/: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/targets/:target_id/webhooks/:id/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/: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/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/targets/:target_id/webhooks/:id/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/webhooks/:id/"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/webhooks/:id/"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/webhooks/: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/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/targets/:target_id/webhooks/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/webhooks/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/events/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/events/")

require "http/client"

url = "{{baseUrl}}/events/"

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}}/events/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/events/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/events/"

	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/events/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/events/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/events/"))
    .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}}/events/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/events/")
  .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}}/events/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/events/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/events/';
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}}/events/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/events/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/events/',
  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}}/events/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/events/');

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}}/events/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/events/';
const options = {method: '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}}/events/"]
                                                       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}}/events/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/events/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/events/');

echo $response->getBody();

setUrl('{{baseUrl}}/events/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/events/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/events/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/events/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/events/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/events/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/events/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/events/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/events/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/events/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/events/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/events/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/events/")! 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}}/webhooks/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/webhooks/")

require "http/client"

url = "{{baseUrl}}/webhooks/"

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}}/webhooks/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhooks/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/webhooks/"

	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/webhooks/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/webhooks/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhooks/"))
    .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}}/webhooks/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/webhooks/")
  .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}}/webhooks/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/webhooks/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/webhooks/';
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}}/webhooks/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/webhooks/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/webhooks/',
  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}}/webhooks/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/webhooks/');

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}}/webhooks/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhooks/';
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}}/webhooks/"]
                                                       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}}/webhooks/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/webhooks/",
  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}}/webhooks/');

echo $response->getBody();

setUrl('{{baseUrl}}/webhooks/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/webhooks/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhooks/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhooks/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/webhooks/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/webhooks/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhooks/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhooks/")

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/webhooks/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/webhooks/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/webhooks/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/webhooks/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhooks/")! 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}}/targets/:target_id/events/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/targets/:target_id/events/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/events/"

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}}/targets/:target_id/events/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/events/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/events/"

	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/targets/:target_id/events/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/targets/:target_id/events/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/events/"))
    .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}}/targets/:target_id/events/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/targets/:target_id/events/")
  .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}}/targets/:target_id/events/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/targets/:target_id/events/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/events/';
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}}/targets/:target_id/events/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/events/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/events/',
  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}}/targets/:target_id/events/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/targets/:target_id/events/');

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}}/targets/:target_id/events/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/events/';
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}}/targets/:target_id/events/"]
                                                       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}}/targets/:target_id/events/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/events/",
  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}}/targets/:target_id/events/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/events/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/events/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/events/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/events/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/targets/:target_id/events/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/events/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/events/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/events/")

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/targets/:target_id/events/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/events/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/targets/:target_id/events/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/events/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/events/")! 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}}/targets/:target_id/webhooks/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/targets/:target_id/webhooks/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/webhooks/"

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}}/targets/:target_id/webhooks/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/webhooks/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/webhooks/"

	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/targets/:target_id/webhooks/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/targets/:target_id/webhooks/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/webhooks/"))
    .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}}/targets/:target_id/webhooks/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/targets/:target_id/webhooks/")
  .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}}/targets/:target_id/webhooks/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/targets/:target_id/webhooks/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/webhooks/';
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}}/targets/:target_id/webhooks/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/webhooks/',
  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}}/targets/:target_id/webhooks/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/targets/:target_id/webhooks/');

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}}/targets/:target_id/webhooks/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/webhooks/';
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}}/targets/:target_id/webhooks/"]
                                                       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}}/targets/:target_id/webhooks/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/webhooks/",
  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}}/targets/:target_id/webhooks/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/webhooks/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/webhooks/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/webhooks/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/webhooks/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/targets/:target_id/webhooks/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/webhooks/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/webhooks/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/webhooks/")

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/targets/:target_id/webhooks/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/webhooks/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/targets/:target_id/webhooks/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/webhooks/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/webhooks/")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/webhooks/: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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/webhooks/:id/" {:content-type :json
                                                           :form-params {:api_version ""
                                                                         :changed ""
                                                                         :changed_by {:email ""
                                                                                      :id ""
                                                                                      :name ""}
                                                                         :check_cert false
                                                                         :created ""
                                                                         :created_by {}
                                                                         :id ""
                                                                         :name ""
                                                                         :url ""}})

require "http/client"

url = "{{baseUrl}}/webhooks/:id/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/webhooks/:id/"),
    Content = new StringContent("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhooks/:id/");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/webhooks/:id/"

	payload := strings.NewReader("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/webhooks/:id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/webhooks/:id/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhooks/:id/"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/webhooks/:id/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/webhooks/:id/")
  .header("content-type", "application/json")
  .body("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/webhooks/:id/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/webhooks/:id/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/webhooks/:id/',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/webhooks/:id/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/webhooks/: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({
  api_version: '',
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  body: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/webhooks/:id/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhooks/:id/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"api_version": @"",
                              @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"check_cert": @NO,
                              @"created": @"",
                              @"created_by": @{  },
                              @"id": @"",
                              @"name": @"",
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/webhooks/:id/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/webhooks/:id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/webhooks/:id/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'api_version' => '',
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'check_cert' => null,
    'created' => '',
    'created_by' => [
        
    ],
    'id' => '',
    'name' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/webhooks/:id/', [
  'body' => '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/webhooks/:id/');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/webhooks/:id/');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhooks/:id/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhooks/:id/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/webhooks/:id/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/webhooks/:id/"

payload = {
    "api_version": "",
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "check_cert": False,
    "created": "",
    "created_by": {},
    "id": "",
    "name": "",
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhooks/:id/"

payload <- "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhooks/:id/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/webhooks/:id/') do |req|
  req.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/webhooks/:id/";

    let payload = json!({
        "api_version": "",
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "check_cert": false,
        "created": "",
        "created_by": json!({}),
        "id": "",
        "name": "",
        "url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}' |  \
  http PATCH {{baseUrl}}/webhooks/:id/ \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/webhooks/:id/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "api_version": "",
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "check_cert": false,
  "created": "",
  "created_by": [],
  "id": "",
  "name": "",
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhooks/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/webhooks/: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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/targets/:target_id/webhooks/:id/" {:content-type :json
                                                                              :form-params {:api_version ""
                                                                                            :changed ""
                                                                                            :changed_by {:email ""
                                                                                                         :id ""
                                                                                                         :name ""}
                                                                                            :check_cert false
                                                                                            :created ""
                                                                                            :created_by {}
                                                                                            :id ""
                                                                                            :name ""
                                                                                            :url ""}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/webhooks/:id/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/webhooks/:id/"),
    Content = new StringContent("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/webhooks/:id/");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/webhooks/:id/"

	payload := strings.NewReader("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/targets/:target_id/webhooks/:id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/webhooks/:id/"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .header("content-type", "application/json")
  .body("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/targets/:target_id/webhooks/:id/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/webhooks/:id/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/webhooks/: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({
  api_version: '',
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  body: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/targets/:target_id/webhooks/:id/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/webhooks/:id/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"api_version": @"",
                              @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"check_cert": @NO,
                              @"created": @"",
                              @"created_by": @{  },
                              @"id": @"",
                              @"name": @"",
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/webhooks/:id/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/targets/:target_id/webhooks/:id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/webhooks/:id/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'api_version' => '',
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'check_cert' => null,
    'created' => '',
    'created_by' => [
        
    ],
    'id' => '',
    'name' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/targets/:target_id/webhooks/:id/', [
  'body' => '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/targets/:target_id/webhooks/:id/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/webhooks/:id/"

payload = {
    "api_version": "",
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "check_cert": False,
    "created": "",
    "created_by": {},
    "id": "",
    "name": "",
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/webhooks/:id/"

payload <- "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/webhooks/:id/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/targets/:target_id/webhooks/:id/') do |req|
  req.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/webhooks/:id/";

    let payload = json!({
        "api_version": "",
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "check_cert": false,
        "created": "",
        "created_by": json!({}),
        "id": "",
        "name": "",
        "url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}' |  \
  http PATCH {{baseUrl}}/targets/:target_id/webhooks/:id/ \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/webhooks/:id/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "api_version": "",
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "check_cert": false,
  "created": "",
  "created_by": [],
  "id": "",
  "name": "",
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/webhooks/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/events/:id/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/events/:id/")

require "http/client"

url = "{{baseUrl}}/events/: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}}/events/:id/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/events/:id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/events/: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/events/:id/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/events/:id/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/events/: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}}/events/:id/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/events/: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}}/events/:id/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/events/:id/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/events/: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}}/events/:id/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/events/:id/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/events/: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}}/events/: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}}/events/: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}}/events/:id/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/events/: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}}/events/: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}}/events/:id/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/events/: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}}/events/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/events/:id/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/events/:id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/events/:id/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/events/:id/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/events/:id/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/events/:id/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/events/:id/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/events/: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/events/:id/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/events/: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}}/events/:id/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/events/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/events/: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}}/webhooks/:id/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/webhooks/:id/")

require "http/client"

url = "{{baseUrl}}/webhooks/: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}}/webhooks/:id/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhooks/:id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/webhooks/: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/webhooks/:id/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/webhooks/:id/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhooks/: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}}/webhooks/:id/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/webhooks/: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}}/webhooks/:id/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/webhooks/:id/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/webhooks/: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}}/webhooks/:id/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/webhooks/:id/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/webhooks/: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}}/webhooks/: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}}/webhooks/: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}}/webhooks/:id/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhooks/: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}}/webhooks/: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}}/webhooks/:id/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/webhooks/: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}}/webhooks/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/webhooks/:id/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/webhooks/:id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhooks/:id/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhooks/:id/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/webhooks/:id/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/webhooks/:id/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhooks/:id/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhooks/: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/webhooks/:id/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/webhooks/: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}}/webhooks/:id/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/webhooks/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhooks/: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}}/targets/:target_id/events/:id/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/targets/:target_id/events/:id/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/events/:id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/events/: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/targets/:target_id/events/:id/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/targets/:target_id/events/:id/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/targets/:target_id/events/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/events/:id/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/events/: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}}/targets/:target_id/events/: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}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/events/:id/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/events/:id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/events/:id/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/events/:id/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/targets/:target_id/events/:id/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/events/:id/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/events/:id/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/events/: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/targets/:target_id/events/:id/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/events/:id/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/events/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/events/: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}}/targets/:target_id/webhooks/:id/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/targets/:target_id/webhooks/:id/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/webhooks/:id/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/webhooks/: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/targets/:target_id/webhooks/:id/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/targets/:target_id/webhooks/:id/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/webhooks/:id/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/webhooks/:id/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/webhooks/: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/targets/:target_id/webhooks/:id/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/webhooks/: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}}/targets/:target_id/webhooks/:id/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/webhooks/:id/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/webhooks/: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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/webhooks/: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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/webhooks/:id/" {:content-type :json
                                                         :form-params {:api_version ""
                                                                       :changed ""
                                                                       :changed_by {:email ""
                                                                                    :id ""
                                                                                    :name ""}
                                                                       :check_cert false
                                                                       :created ""
                                                                       :created_by {}
                                                                       :id ""
                                                                       :name ""
                                                                       :url ""}})

require "http/client"

url = "{{baseUrl}}/webhooks/:id/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/webhooks/:id/"),
    Content = new StringContent("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/webhooks/:id/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/webhooks/:id/"

	payload := strings.NewReader("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/webhooks/:id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/webhooks/:id/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/webhooks/:id/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/webhooks/:id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/webhooks/:id/")
  .header("content-type", "application/json")
  .body("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/webhooks/:id/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/webhooks/:id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/webhooks/:id/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/webhooks/:id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/webhooks/: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({
  api_version: '',
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  body: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/webhooks/:id/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/webhooks/:id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"api_version": @"",
                              @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"check_cert": @NO,
                              @"created": @"",
                              @"created_by": @{  },
                              @"id": @"",
                              @"name": @"",
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/webhooks/:id/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/webhooks/:id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/webhooks/:id/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'api_version' => '',
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'check_cert' => null,
    'created' => '',
    'created_by' => [
        
    ],
    'id' => '',
    'name' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/webhooks/:id/', [
  'body' => '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/webhooks/:id/');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/webhooks/:id/');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/webhooks/:id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/webhooks/:id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/webhooks/:id/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/webhooks/:id/"

payload = {
    "api_version": "",
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "check_cert": False,
    "created": "",
    "created_by": {},
    "id": "",
    "name": "",
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/webhooks/:id/"

payload <- "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/webhooks/:id/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/webhooks/:id/') do |req|
  req.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/webhooks/:id/";

    let payload = json!({
        "api_version": "",
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "check_cert": false,
        "created": "",
        "created_by": json!({}),
        "id": "",
        "name": "",
        "url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}' |  \
  http PUT {{baseUrl}}/webhooks/:id/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/webhooks/:id/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "api_version": "",
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "check_cert": false,
  "created": "",
  "created_by": [],
  "id": "",
  "name": "",
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/webhooks/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/webhooks/: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  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/targets/:target_id/webhooks/:id/" {:content-type :json
                                                                            :form-params {:api_version ""
                                                                                          :changed ""
                                                                                          :changed_by {:email ""
                                                                                                       :id ""
                                                                                                       :name ""}
                                                                                          :check_cert false
                                                                                          :created ""
                                                                                          :created_by {}
                                                                                          :id ""
                                                                                          :name ""
                                                                                          :url ""}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/webhooks/:id/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/webhooks/:id/"),
    Content = new StringContent("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/webhooks/:id/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/webhooks/:id/"

	payload := strings.NewReader("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/targets/:target_id/webhooks/:id/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/webhooks/:id/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .header("content-type", "application/json")
  .body("{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/targets/:target_id/webhooks/:id/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/webhooks/:id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/webhooks/:id/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/webhooks/: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({
  api_version: '',
  changed: '',
  changed_by: {email: '', id: '', name: ''},
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  body: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/targets/:target_id/webhooks/:id/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  api_version: '',
  changed: '',
  changed_by: {
    email: '',
    id: '',
    name: ''
  },
  check_cert: false,
  created: '',
  created_by: {},
  id: '',
  name: '',
  url: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/targets/:target_id/webhooks/:id/',
  headers: {'content-type': 'application/json'},
  data: {
    api_version: '',
    changed: '',
    changed_by: {email: '', id: '', name: ''},
    check_cert: false,
    created: '',
    created_by: {},
    id: '',
    name: '',
    url: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/webhooks/:id/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"api_version":"","changed":"","changed_by":{"email":"","id":"","name":""},"check_cert":false,"created":"","created_by":{},"id":"","name":"","url":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"api_version": @"",
                              @"changed": @"",
                              @"changed_by": @{ @"email": @"", @"id": @"", @"name": @"" },
                              @"check_cert": @NO,
                              @"created": @"",
                              @"created_by": @{  },
                              @"id": @"",
                              @"name": @"",
                              @"url": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/webhooks/:id/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/targets/:target_id/webhooks/:id/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/webhooks/:id/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'api_version' => '',
    'changed' => '',
    'changed_by' => [
        'email' => '',
        'id' => '',
        'name' => ''
    ],
    'check_cert' => null,
    'created' => '',
    'created_by' => [
        
    ],
    'id' => '',
    'name' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/targets/:target_id/webhooks/:id/', [
  'body' => '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'api_version' => '',
  'changed' => '',
  'changed_by' => [
    'email' => '',
    'id' => '',
    'name' => ''
  ],
  'check_cert' => null,
  'created' => '',
  'created_by' => [
    
  ],
  'id' => '',
  'name' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/webhooks/:id/');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/webhooks/:id/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/targets/:target_id/webhooks/:id/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/webhooks/:id/"

payload = {
    "api_version": "",
    "changed": "",
    "changed_by": {
        "email": "",
        "id": "",
        "name": ""
    },
    "check_cert": False,
    "created": "",
    "created_by": {},
    "id": "",
    "name": "",
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/webhooks/:id/"

payload <- "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/webhooks/:id/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/targets/:target_id/webhooks/:id/') do |req|
  req.body = "{\n  \"api_version\": \"\",\n  \"changed\": \"\",\n  \"changed_by\": {\n    \"email\": \"\",\n    \"id\": \"\",\n    \"name\": \"\"\n  },\n  \"check_cert\": false,\n  \"created\": \"\",\n  \"created_by\": {},\n  \"id\": \"\",\n  \"name\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/webhooks/:id/";

    let payload = json!({
        "api_version": "",
        "changed": "",
        "changed_by": json!({
            "email": "",
            "id": "",
            "name": ""
        }),
        "check_cert": false,
        "created": "",
        "created_by": json!({}),
        "id": "",
        "name": "",
        "url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "api_version": "",
  "changed": "",
  "changed_by": {
    "email": "",
    "id": "",
    "name": ""
  },
  "check_cert": false,
  "created": "",
  "created_by": {},
  "id": "",
  "name": "",
  "url": ""
}' |  \
  http PUT {{baseUrl}}/targets/:target_id/webhooks/:id/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "api_version": "",\n  "changed": "",\n  "changed_by": {\n    "email": "",\n    "id": "",\n    "name": ""\n  },\n  "check_cert": false,\n  "created": "",\n  "created_by": {},\n  "id": "",\n  "name": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/webhooks/:id/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "api_version": "",
  "changed": "",
  "changed_by": [
    "email": "",
    "id": "",
    "name": ""
  ],
  "check_cert": false,
  "created": "",
  "created_by": [],
  "id": "",
  "name": "",
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/webhooks/:id/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/findings/bulk/retest/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/targets/:target_id/findings/bulk/retest/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/findings/bulk/retest/"

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}}/targets/:target_id/findings/bulk/retest/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/findings/bulk/retest/");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/findings/bulk/retest/"

	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/targets/:target_id/findings/bulk/retest/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/targets/:target_id/findings/bulk/retest/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/findings/bulk/retest/"))
    .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}}/targets/:target_id/findings/bulk/retest/")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/targets/:target_id/findings/bulk/retest/")
  .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}}/targets/:target_id/findings/bulk/retest/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/retest/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/findings/bulk/retest/';
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}}/targets/:target_id/findings/bulk/retest/',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/bulk/retest/")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/findings/bulk/retest/',
  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}}/targets/:target_id/findings/bulk/retest/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/targets/:target_id/findings/bulk/retest/');

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}}/targets/:target_id/findings/bulk/retest/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/findings/bulk/retest/';
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}}/targets/:target_id/findings/bulk/retest/"]
                                                       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}}/targets/:target_id/findings/bulk/retest/" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/findings/bulk/retest/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/targets/:target_id/findings/bulk/retest/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/findings/bulk/retest/');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/findings/bulk/retest/');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/findings/bulk/retest/' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/findings/bulk/retest/' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/targets/:target_id/findings/bulk/retest/", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/findings/bulk/retest/"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/findings/bulk/retest/"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/findings/bulk/retest/")

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/targets/:target_id/findings/bulk/retest/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/findings/bulk/retest/";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/targets/:target_id/findings/bulk/retest/

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/targets/:target_id/findings/bulk/retest/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/findings/bulk/retest/")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/findings/bulk/update/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/targets/:target_id/findings/bulk/update/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/findings/bulk/update/"

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/findings/bulk/update/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/findings/bulk/update/");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/findings/bulk/update/"

	req, _ := http.NewRequest("PATCH", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/targets/:target_id/findings/bulk/update/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/targets/:target_id/findings/bulk/update/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/findings/bulk/update/"))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/bulk/update/")
  .patch(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/targets/:target_id/findings/bulk/update/")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/targets/:target_id/findings/bulk/update/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/update/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/findings/bulk/update/';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/update/',
  method: 'PATCH',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/bulk/update/")
  .patch(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/findings/bulk/update/',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/update/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/targets/:target_id/findings/bulk/update/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/update/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/findings/bulk/update/';
const options = {method: 'PATCH'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/findings/bulk/update/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/targets/:target_id/findings/bulk/update/" in

Client.call `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/findings/bulk/update/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/targets/:target_id/findings/bulk/update/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/findings/bulk/update/');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/findings/bulk/update/');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/findings/bulk/update/' -Method PATCH 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/findings/bulk/update/' -Method PATCH 

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("PATCH", "/baseUrl/targets/:target_id/findings/bulk/update/", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/findings/bulk/update/"

payload = ""

response = requests.patch(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/findings/bulk/update/"

payload <- ""

response <- VERB("PATCH", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/findings/bulk/update/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/targets/:target_id/findings/bulk/update/') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/findings/bulk/update/";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PATCH {{baseUrl}}/targets/:target_id/findings/bulk/update/

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/targets/:target_id/findings/bulk/update/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/findings/bulk/update/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/findings/:id/log/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/targets/:target_id/findings/:id/log/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/findings/:id/log/"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/targets/:target_id/findings/:id/log/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/findings/:id/log/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/findings/:id/log/"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/targets/:target_id/findings/:id/log/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/targets/:target_id/findings/:id/log/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/findings/:id/log/"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/:id/log/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/targets/:target_id/findings/:id/log/")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/targets/:target_id/findings/:id/log/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/targets/:target_id/findings/:id/log/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/findings/:id/log/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/targets/:target_id/findings/:id/log/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/:id/log/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/findings/:id/log/',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/targets/:target_id/findings/:id/log/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/targets/:target_id/findings/:id/log/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/targets/:target_id/findings/:id/log/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/findings/:id/log/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/findings/:id/log/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/targets/:target_id/findings/:id/log/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/findings/:id/log/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/targets/:target_id/findings/:id/log/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/findings/:id/log/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/findings/:id/log/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/findings/:id/log/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/findings/:id/log/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/targets/:target_id/findings/:id/log/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/findings/:id/log/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/findings/:id/log/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/targets/:target_id/findings/:id/log/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/targets/:target_id/findings/:id/log/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/findings/:id/log/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/targets/:target_id/findings/:id/log/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/targets/:target_id/findings/:id/log/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/findings/:id/log/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/findings/bulk/report/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ids\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/targets/:target_id/findings/bulk/report/" {:content-type :json
                                                                                     :form-params {:ids []}})

require "http/client"

url = "{{baseUrl}}/targets/:target_id/findings/bulk/report/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ids\": []\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}}/targets/:target_id/findings/bulk/report/"),
    Content = new StringContent("{\n  \"ids\": []\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}}/targets/:target_id/findings/bulk/report/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ids\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/findings/bulk/report/"

	payload := strings.NewReader("{\n  \"ids\": []\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/targets/:target_id/findings/bulk/report/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "ids": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/targets/:target_id/findings/bulk/report/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ids\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/findings/bulk/report/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ids\": []\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  \"ids\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/bulk/report/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/targets/:target_id/findings/bulk/report/")
  .header("content-type", "application/json")
  .body("{\n  \"ids\": []\n}")
  .asString();

const data = JSON.stringify({
  ids: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/targets/:target_id/findings/bulk/report/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/report/',
  headers: {'content-type': 'application/json'},
  data: {ids: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/findings/bulk/report/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ids":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/report/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ids": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ids\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/bulk/report/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/findings/bulk/report/',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ids: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/targets/:target_id/findings/bulk/report/',
  headers: {'content-type': 'application/json'},
  body: {ids: []},
  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}}/targets/:target_id/findings/bulk/report/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ids: []
});

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}}/targets/:target_id/findings/bulk/report/',
  headers: {'content-type': 'application/json'},
  data: {ids: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/findings/bulk/report/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ids":[]}'
};

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 = @{ @"ids": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/targets/:target_id/findings/bulk/report/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/targets/:target_id/findings/bulk/report/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ids\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/findings/bulk/report/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ids' => [
        
    ]
  ]),
  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}}/targets/:target_id/findings/bulk/report/', [
  'body' => '{
  "ids": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/findings/bulk/report/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ids' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ids' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/targets/:target_id/findings/bulk/report/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/findings/bulk/report/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ids": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/findings/bulk/report/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ids": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ids\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/targets/:target_id/findings/bulk/report/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/findings/bulk/report/"

payload = { "ids": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/targets/:target_id/findings/bulk/report/"

payload <- "{\n  \"ids\": []\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}}/targets/:target_id/findings/bulk/report/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ids\": []\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/targets/:target_id/findings/bulk/report/') do |req|
  req.body = "{\n  \"ids\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/targets/:target_id/findings/bulk/report/";

    let payload = json!({"ids": ()});

    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 '{
  "ids": []
}' |  \
  http POST {{baseUrl}}/targets/:target_id/findings/bulk/report/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ids": []\n}' \
  --output-document \
  - {{baseUrl}}/targets/:target_id/findings/bulk/report/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ids": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/targets/:target_id/findings/bulk/report/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/targets/:target_id/findings/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/targets/:target_id/findings/")

require "http/client"

url = "{{baseUrl}}/targets/:target_id/findings/"

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}}/targets/:target_id/findings/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/targets/:target_id/findings/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/targets/:target_id/findings/"

	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/targets/:target_id/findings/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/targets/:target_id/findings/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/targets/:target_id/findings/"))
    .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}}/targets/:target_id/findings/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/targets/:target_id/findings/")
  .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}}/targets/:target_id/findings/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/targets/:target_id/findings/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/targets/:target_id/findings/';
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}}/targets/:target_id/findings/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/targets/:target_id/findings/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/targets/:target_id/findings/',
  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}}/targets/:target_id/findings/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/targets/:target_id/findings/');

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}}/targets/:target_id/findings/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/targets/:target_id/findings/';
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}}/targets/:target_id/findings/"]
                                                       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}}/targets/:target_id/findings/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/targets/:target_id/findings/",
  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}}/targets/:target_id/findings/');

echo $response->getBody();

setUrl('{{baseUrl}}/targets/:target_id/findings/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/targets/:target_id/findings/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/targets/:target_id/findings/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/targets/:target_id/findings/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/targets/:target_id/findings/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/targets/:target_id/findings/"

response = requests.get(url)

print(response.json())