ExaVaultv2.0

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/account" {:headers {:ev-api-key ""
                                                             :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/account"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/account"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
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);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	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
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/account")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/account")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/account');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/account';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await 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: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/account',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

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

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", 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
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `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",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/account', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/account');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

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

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

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

import requests

url = "{{baseUrl}}/account"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), 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)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/account') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/account \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/account

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/account");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/account" {:headers {:ev-api-key ""
                                                               :ev-access-token ""}
                                                     :content-type :json
                                                     :form-params {:accountOnboarding false
                                                                   :allowedIpRanges [{:ipEnd ""
                                                                                      :ipStart ""}]
                                                                   :brandingSettings {:companyName ""
                                                                                      :customEmail ""
                                                                                      :theme ""}
                                                                   :complexPasswords false
                                                                   :customSignature ""
                                                                   :emailContent ""
                                                                   :emailSubject ""
                                                                   :externalDomain ""
                                                                   :quota {:noticeEnabled false
                                                                           :noticeThreshold 0
                                                                           :transactionsNoticeEnabled false
                                                                           :transactionsNoticeThreshold 0}
                                                                   :secureOnly false
                                                                   :showReferralLinks false}})

require "http/client"

url = "{{baseUrl}}/account"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": 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}}/account"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": 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}}/account");
var request = new RestRequest("", Method.Patch);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/account HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 526

{
  "accountOnboarding": false,
  "allowedIpRanges": [
    {
      "ipEnd": "",
      "ipStart": ""
    }
  ],
  "brandingSettings": {
    "companyName": "",
    "customEmail": "",
    "theme": ""
  },
  "complexPasswords": false,
  "customSignature": "",
  "emailContent": "",
  "emailSubject": "",
  "externalDomain": "",
  "quota": {
    "noticeEnabled": false,
    "noticeThreshold": 0,
    "transactionsNoticeEnabled": false,
    "transactionsNoticeThreshold": 0
  },
  "secureOnly": false,
  "showReferralLinks": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/account")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": 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  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/account")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}")
  .asString();

const data = JSON.stringify({
  accountOnboarding: false,
  allowedIpRanges: [
    {
      ipEnd: '',
      ipStart: ''
    }
  ],
  brandingSettings: {
    companyName: '',
    customEmail: '',
    theme: ''
  },
  complexPasswords: false,
  customSignature: '',
  emailContent: '',
  emailSubject: '',
  externalDomain: '',
  quota: {
    noticeEnabled: false,
    noticeThreshold: 0,
    transactionsNoticeEnabled: false,
    transactionsNoticeThreshold: 0
  },
  secureOnly: false,
  showReferralLinks: 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}}/account');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/account',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    accountOnboarding: false,
    allowedIpRanges: [{ipEnd: '', ipStart: ''}],
    brandingSettings: {companyName: '', customEmail: '', theme: ''},
    complexPasswords: false,
    customSignature: '',
    emailContent: '',
    emailSubject: '',
    externalDomain: '',
    quota: {
      noticeEnabled: false,
      noticeThreshold: 0,
      transactionsNoticeEnabled: false,
      transactionsNoticeThreshold: 0
    },
    secureOnly: false,
    showReferralLinks: false
  }
};

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

const url = '{{baseUrl}}/account';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"accountOnboarding":false,"allowedIpRanges":[{"ipEnd":"","ipStart":""}],"brandingSettings":{"companyName":"","customEmail":"","theme":""},"complexPasswords":false,"customSignature":"","emailContent":"","emailSubject":"","externalDomain":"","quota":{"noticeEnabled":false,"noticeThreshold":0,"transactionsNoticeEnabled":false,"transactionsNoticeThreshold":0},"secureOnly":false,"showReferralLinks":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}}/account',
  method: 'PATCH',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountOnboarding": false,\n  "allowedIpRanges": [\n    {\n      "ipEnd": "",\n      "ipStart": ""\n    }\n  ],\n  "brandingSettings": {\n    "companyName": "",\n    "customEmail": "",\n    "theme": ""\n  },\n  "complexPasswords": false,\n  "customSignature": "",\n  "emailContent": "",\n  "emailSubject": "",\n  "externalDomain": "",\n  "quota": {\n    "noticeEnabled": false,\n    "noticeThreshold": 0,\n    "transactionsNoticeEnabled": false,\n    "transactionsNoticeThreshold": 0\n  },\n  "secureOnly": false,\n  "showReferralLinks": 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  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/account',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({
  accountOnboarding: false,
  allowedIpRanges: [{ipEnd: '', ipStart: ''}],
  brandingSettings: {companyName: '', customEmail: '', theme: ''},
  complexPasswords: false,
  customSignature: '',
  emailContent: '',
  emailSubject: '',
  externalDomain: '',
  quota: {
    noticeEnabled: false,
    noticeThreshold: 0,
    transactionsNoticeEnabled: false,
    transactionsNoticeThreshold: 0
  },
  secureOnly: false,
  showReferralLinks: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/account',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {
    accountOnboarding: false,
    allowedIpRanges: [{ipEnd: '', ipStart: ''}],
    brandingSettings: {companyName: '', customEmail: '', theme: ''},
    complexPasswords: false,
    customSignature: '',
    emailContent: '',
    emailSubject: '',
    externalDomain: '',
    quota: {
      noticeEnabled: false,
      noticeThreshold: 0,
      transactionsNoticeEnabled: false,
      transactionsNoticeThreshold: 0
    },
    secureOnly: false,
    showReferralLinks: 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}}/account');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  accountOnboarding: false,
  allowedIpRanges: [
    {
      ipEnd: '',
      ipStart: ''
    }
  ],
  brandingSettings: {
    companyName: '',
    customEmail: '',
    theme: ''
  },
  complexPasswords: false,
  customSignature: '',
  emailContent: '',
  emailSubject: '',
  externalDomain: '',
  quota: {
    noticeEnabled: false,
    noticeThreshold: 0,
    transactionsNoticeEnabled: false,
    transactionsNoticeThreshold: 0
  },
  secureOnly: false,
  showReferralLinks: 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}}/account',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    accountOnboarding: false,
    allowedIpRanges: [{ipEnd: '', ipStart: ''}],
    brandingSettings: {companyName: '', customEmail: '', theme: ''},
    complexPasswords: false,
    customSignature: '',
    emailContent: '',
    emailSubject: '',
    externalDomain: '',
    quota: {
      noticeEnabled: false,
      noticeThreshold: 0,
      transactionsNoticeEnabled: false,
      transactionsNoticeThreshold: 0
    },
    secureOnly: false,
    showReferralLinks: false
  }
};

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: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"accountOnboarding":false,"allowedIpRanges":[{"ipEnd":"","ipStart":""}],"brandingSettings":{"companyName":"","customEmail":"","theme":""},"complexPasswords":false,"customSignature":"","emailContent":"","emailSubject":"","externalDomain":"","quota":{"noticeEnabled":false,"noticeThreshold":0,"transactionsNoticeEnabled":false,"transactionsNoticeThreshold":0},"secureOnly":false,"showReferralLinks":false}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"accountOnboarding": @NO,
                              @"allowedIpRanges": @[ @{ @"ipEnd": @"", @"ipStart": @"" } ],
                              @"brandingSettings": @{ @"companyName": @"", @"customEmail": @"", @"theme": @"" },
                              @"complexPasswords": @NO,
                              @"customSignature": @"",
                              @"emailContent": @"",
                              @"emailSubject": @"",
                              @"externalDomain": @"",
                              @"quota": @{ @"noticeEnabled": @NO, @"noticeThreshold": @0, @"transactionsNoticeEnabled": @NO, @"transactionsNoticeThreshold": @0 },
                              @"secureOnly": @NO,
                              @"showReferralLinks": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account"]
                                                       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}}/account" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}" in

Client.call ~headers ~body `PATCH 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 => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'accountOnboarding' => null,
    'allowedIpRanges' => [
        [
                'ipEnd' => '',
                'ipStart' => ''
        ]
    ],
    'brandingSettings' => [
        'companyName' => '',
        'customEmail' => '',
        'theme' => ''
    ],
    'complexPasswords' => null,
    'customSignature' => '',
    'emailContent' => '',
    'emailSubject' => '',
    'externalDomain' => '',
    'quota' => [
        'noticeEnabled' => null,
        'noticeThreshold' => 0,
        'transactionsNoticeEnabled' => null,
        'transactionsNoticeThreshold' => 0
    ],
    'secureOnly' => null,
    'showReferralLinks' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/account', [
  'body' => '{
  "accountOnboarding": false,
  "allowedIpRanges": [
    {
      "ipEnd": "",
      "ipStart": ""
    }
  ],
  "brandingSettings": {
    "companyName": "",
    "customEmail": "",
    "theme": ""
  },
  "complexPasswords": false,
  "customSignature": "",
  "emailContent": "",
  "emailSubject": "",
  "externalDomain": "",
  "quota": {
    "noticeEnabled": false,
    "noticeThreshold": 0,
    "transactionsNoticeEnabled": false,
    "transactionsNoticeThreshold": 0
  },
  "secureOnly": false,
  "showReferralLinks": false
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountOnboarding' => null,
  'allowedIpRanges' => [
    [
        'ipEnd' => '',
        'ipStart' => ''
    ]
  ],
  'brandingSettings' => [
    'companyName' => '',
    'customEmail' => '',
    'theme' => ''
  ],
  'complexPasswords' => null,
  'customSignature' => '',
  'emailContent' => '',
  'emailSubject' => '',
  'externalDomain' => '',
  'quota' => [
    'noticeEnabled' => null,
    'noticeThreshold' => 0,
    'transactionsNoticeEnabled' => null,
    'transactionsNoticeThreshold' => 0
  ],
  'secureOnly' => null,
  'showReferralLinks' => null
]));

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

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

append(json_encode([
  'accountOnboarding' => null,
  'allowedIpRanges' => [
    [
        'ipEnd' => '',
        'ipStart' => ''
    ]
  ],
  'brandingSettings' => [
    'companyName' => '',
    'customEmail' => '',
    'theme' => ''
  ],
  'complexPasswords' => null,
  'customSignature' => '',
  'emailContent' => '',
  'emailSubject' => '',
  'externalDomain' => '',
  'quota' => [
    'noticeEnabled' => null,
    'noticeThreshold' => 0,
    'transactionsNoticeEnabled' => null,
    'transactionsNoticeThreshold' => 0
  ],
  'secureOnly' => null,
  'showReferralLinks' => null
]));
$request->setRequestUrl('{{baseUrl}}/account');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/account' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "accountOnboarding": false,
  "allowedIpRanges": [
    {
      "ipEnd": "",
      "ipStart": ""
    }
  ],
  "brandingSettings": {
    "companyName": "",
    "customEmail": "",
    "theme": ""
  },
  "complexPasswords": false,
  "customSignature": "",
  "emailContent": "",
  "emailSubject": "",
  "externalDomain": "",
  "quota": {
    "noticeEnabled": false,
    "noticeThreshold": 0,
    "transactionsNoticeEnabled": false,
    "transactionsNoticeThreshold": 0
  },
  "secureOnly": false,
  "showReferralLinks": false
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "accountOnboarding": false,
  "allowedIpRanges": [
    {
      "ipEnd": "",
      "ipStart": ""
    }
  ],
  "brandingSettings": {
    "companyName": "",
    "customEmail": "",
    "theme": ""
  },
  "complexPasswords": false,
  "customSignature": "",
  "emailContent": "",
  "emailSubject": "",
  "externalDomain": "",
  "quota": {
    "noticeEnabled": false,
    "noticeThreshold": 0,
    "transactionsNoticeEnabled": false,
    "transactionsNoticeThreshold": 0
  },
  "secureOnly": false,
  "showReferralLinks": false
}'

import http.client

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

payload = "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/account"

payload = {
    "accountOnboarding": False,
    "allowedIpRanges": [
        {
            "ipEnd": "",
            "ipStart": ""
        }
    ],
    "brandingSettings": {
        "companyName": "",
        "customEmail": "",
        "theme": ""
    },
    "complexPasswords": False,
    "customSignature": "",
    "emailContent": "",
    "emailSubject": "",
    "externalDomain": "",
    "quota": {
        "noticeEnabled": False,
        "noticeThreshold": 0,
        "transactionsNoticeEnabled": False,
        "transactionsNoticeThreshold": 0
    },
    "secureOnly": False,
    "showReferralLinks": False
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": false\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

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::Patch.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": 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/account') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"accountOnboarding\": false,\n  \"allowedIpRanges\": [\n    {\n      \"ipEnd\": \"\",\n      \"ipStart\": \"\"\n    }\n  ],\n  \"brandingSettings\": {\n    \"companyName\": \"\",\n    \"customEmail\": \"\",\n    \"theme\": \"\"\n  },\n  \"complexPasswords\": false,\n  \"customSignature\": \"\",\n  \"emailContent\": \"\",\n  \"emailSubject\": \"\",\n  \"externalDomain\": \"\",\n  \"quota\": {\n    \"noticeEnabled\": false,\n    \"noticeThreshold\": 0,\n    \"transactionsNoticeEnabled\": false,\n    \"transactionsNoticeThreshold\": 0\n  },\n  \"secureOnly\": false,\n  \"showReferralLinks\": 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}}/account";

    let payload = json!({
        "accountOnboarding": false,
        "allowedIpRanges": (
            json!({
                "ipEnd": "",
                "ipStart": ""
            })
        ),
        "brandingSettings": json!({
            "companyName": "",
            "customEmail": "",
            "theme": ""
        }),
        "complexPasswords": false,
        "customSignature": "",
        "emailContent": "",
        "emailSubject": "",
        "externalDomain": "",
        "quota": json!({
            "noticeEnabled": false,
            "noticeThreshold": 0,
            "transactionsNoticeEnabled": false,
            "transactionsNoticeThreshold": 0
        }),
        "secureOnly": false,
        "showReferralLinks": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "accountOnboarding": false,
  "allowedIpRanges": [
    {
      "ipEnd": "",
      "ipStart": ""
    }
  ],
  "brandingSettings": {
    "companyName": "",
    "customEmail": "",
    "theme": ""
  },
  "complexPasswords": false,
  "customSignature": "",
  "emailContent": "",
  "emailSubject": "",
  "externalDomain": "",
  "quota": {
    "noticeEnabled": false,
    "noticeThreshold": 0,
    "transactionsNoticeEnabled": false,
    "transactionsNoticeThreshold": 0
  },
  "secureOnly": false,
  "showReferralLinks": false
}' |  \
  http PATCH {{baseUrl}}/account \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method PATCH \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountOnboarding": false,\n  "allowedIpRanges": [\n    {\n      "ipEnd": "",\n      "ipStart": ""\n    }\n  ],\n  "brandingSettings": {\n    "companyName": "",\n    "customEmail": "",\n    "theme": ""\n  },\n  "complexPasswords": false,\n  "customSignature": "",\n  "emailContent": "",\n  "emailSubject": "",\n  "externalDomain": "",\n  "quota": {\n    "noticeEnabled": false,\n    "noticeThreshold": 0,\n    "transactionsNoticeEnabled": false,\n    "transactionsNoticeThreshold": 0\n  },\n  "secureOnly": false,\n  "showReferralLinks": false\n}' \
  --output-document \
  - {{baseUrl}}/account

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "accountOnboarding": false,
  "allowedIpRanges": [
    [
      "ipEnd": "",
      "ipStart": ""
    ]
  ],
  "brandingSettings": [
    "companyName": "",
    "customEmail": "",
    "theme": ""
  ],
  "complexPasswords": false,
  "customSignature": "",
  "emailContent": "",
  "emailSubject": "",
  "externalDomain": "",
  "quota": [
    "noticeEnabled": false,
    "noticeThreshold": 0,
    "transactionsNoticeEnabled": false,
    "transactionsNoticeThreshold": 0
  ],
  "secureOnly": false,
  "showReferralLinks": false
] as [String : Any]

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

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/activity/session" {:headers {:ev-api-key ""
                                                                      :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/activity/session"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/activity/session"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/activity/session");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/activity/session"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/activity/session HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/activity/session")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/activity/session"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/activity/session")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/activity/session")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/activity/session');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/activity/session',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/activity/session';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/activity/session',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/activity/session")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/activity/session',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/activity/session',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/activity/session',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/activity/session';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/activity/session"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/activity/session" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/activity/session",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/activity/session', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/activity/session');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/activity/session' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/activity/session' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/activity/session", headers=headers)

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

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

import requests

url = "{{baseUrl}}/activity/session"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/activity/session"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/activity/session")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/activity/session') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/activity/session \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/activity/session

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/activity/webhooks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/activity/webhooks" {:headers {:ev-api-key ""
                                                                       :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/activity/webhooks"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/activity/webhooks"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/activity/webhooks");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/activity/webhooks"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/activity/webhooks HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/activity/webhooks")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/activity/webhooks"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/activity/webhooks")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/activity/webhooks")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/activity/webhooks');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/activity/webhooks',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/activity/webhooks';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/activity/webhooks',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/activity/webhooks")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/activity/webhooks',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/activity/webhooks',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/activity/webhooks',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/activity/webhooks';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/activity/webhooks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/activity/webhooks" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/activity/webhooks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/activity/webhooks', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/activity/webhooks');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/activity/webhooks' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/activity/webhooks' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/activity/webhooks", headers=headers)

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

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

import requests

url = "{{baseUrl}}/activity/webhooks"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/activity/webhooks"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/activity/webhooks")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/activity/webhooks') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/activity/webhooks \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/activity/webhooks

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/email/welcome/:username");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/email/welcome/:username" {:headers {:ev-api-key ""
                                                                              :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/email/welcome/:username"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/email/welcome/:username"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/email/welcome/:username");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/email/welcome/:username"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

POST /baseUrl/email/welcome/:username HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/email/welcome/:username")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/email/welcome/:username"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/email/welcome/:username")
  .post(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/email/welcome/:username")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/email/welcome/:username');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/email/welcome/:username',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/email/welcome/:username';
const options = {method: 'POST', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/email/welcome/:username',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/email/welcome/:username")
  .post(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/email/welcome/:username',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/email/welcome/:username',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/email/welcome/:username');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/email/welcome/:username',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/email/welcome/:username';
const options = {method: 'POST', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email/welcome/:username"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/email/welcome/:username" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/email/welcome/:username",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/email/welcome/:username', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/email/welcome/:username');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/email/welcome/:username');
$request->setRequestMethod('POST');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email/welcome/:username' -Method POST -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email/welcome/:username' -Method POST -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("POST", "/baseUrl/email/welcome/:username", headers=headers)

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

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

import requests

url = "{{baseUrl}}/email/welcome/:username"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/email/welcome/:username"

response <- VERB("POST", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/email/welcome/:username")

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

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/email/welcome/:username') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http POST {{baseUrl}}/email/welcome/:username \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/email/welcome/:username

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/email/referral");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"emails\": [],\n  \"message\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/email/referral" {:headers {:ev-api-key ""
                                                                     :ev-access-token ""}
                                                           :content-type :json
                                                           :form-params {:emails []
                                                                         :message ""}})

require "http/client"

url = "{{baseUrl}}/email/referral"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"emails\": [],\n  \"message\": \"\"\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}}/email/referral"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"emails\": [],\n  \"message\": \"\"\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}}/email/referral");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"emails\": [],\n  \"message\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/email/referral"

	payload := strings.NewReader("{\n  \"emails\": [],\n  \"message\": \"\"\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/email/referral HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "emails": [],
  "message": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/email/referral")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"emails\": [],\n  \"message\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/email/referral"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"emails\": [],\n  \"message\": \"\"\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  \"emails\": [],\n  \"message\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/email/referral")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/email/referral")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"emails\": [],\n  \"message\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  emails: [],
  message: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/email/referral');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/email/referral',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {emails: [], message: ''}
};

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

const url = '{{baseUrl}}/email/referral';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"emails":[],"message":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/email/referral',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "emails": [],\n  "message": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"emails\": [],\n  \"message\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/email/referral")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/email/referral',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({emails: [], message: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/email/referral',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {emails: [], message: ''},
  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}}/email/referral');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  emails: [],
  message: ''
});

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}}/email/referral',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {emails: [], message: ''}
};

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

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

const url = '{{baseUrl}}/email/referral';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"emails":[],"message":""}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"emails": @[  ],
                              @"message": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email/referral"]
                                                       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}}/email/referral" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"emails\": [],\n  \"message\": \"\"\n}" in

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

 "{{baseUrl}}/email/referral",
  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([
    'emails' => [
        
    ],
    'message' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/email/referral', [
  'body' => '{
  "emails": [],
  "message": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'emails' => [
    
  ],
  'message' => ''
]));
$request->setRequestUrl('{{baseUrl}}/email/referral');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email/referral' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "emails": [],
  "message": ""
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email/referral' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "emails": [],
  "message": ""
}'

import http.client

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

payload = "{\n  \"emails\": [],\n  \"message\": \"\"\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/email/referral"

payload = {
    "emails": [],
    "message": ""
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/email/referral"

payload <- "{\n  \"emails\": [],\n  \"message\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/email/referral")

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

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"emails\": [],\n  \"message\": \"\"\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/email/referral') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"emails\": [],\n  \"message\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "emails": (),
        "message": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "emails": [],
  "message": ""
}' |  \
  http POST {{baseUrl}}/email/referral \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "emails": [],\n  "message": ""\n}' \
  --output-document \
  - {{baseUrl}}/email/referral

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "emails": [],
  "message": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"emails\": [],\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/email-lists" {:headers {:ev-api-key ""
                                                                  :ev-access-token ""}
                                                        :content-type :json
                                                        :form-params {:emails []
                                                                      :name ""}})

require "http/client"

url = "{{baseUrl}}/email-lists"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"emails\": [],\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}}/email-lists"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"emails\": [],\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}}/email-lists");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"emails\": [],\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/email-lists"

	payload := strings.NewReader("{\n  \"emails\": [],\n  \"name\": \"\"\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/email-lists HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "emails": [],
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/email-lists")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"emails\": [],\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/email-lists"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"emails\": [],\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  \"emails\": [],\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/email-lists")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/email-lists")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"emails\": [],\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  emails: [],
  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}}/email-lists');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/email-lists',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {emails: [], name: ''}
};

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

const url = '{{baseUrl}}/email-lists';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"emails":[],"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}}/email-lists',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "emails": [],\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  \"emails\": [],\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/email-lists")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/email-lists',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({emails: [], name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/email-lists',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {emails: [], 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}}/email-lists');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  emails: [],
  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}}/email-lists',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {emails: [], name: ''}
};

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

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

const url = '{{baseUrl}}/email-lists';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"emails":[],"name":""}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"emails": @[  ],
                              @"name": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email-lists"]
                                                       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}}/email-lists" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"emails\": [],\n  \"name\": \"\"\n}" in

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

 "{{baseUrl}}/email-lists",
  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([
    'emails' => [
        
    ],
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/email-lists', [
  'body' => '{
  "emails": [],
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'emails' => [
    
  ],
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/email-lists');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email-lists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "emails": [],
  "name": ""
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email-lists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "emails": [],
  "name": ""
}'

import http.client

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

payload = "{\n  \"emails\": [],\n  \"name\": \"\"\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/email-lists", payload, headers)

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

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

import requests

url = "{{baseUrl}}/email-lists"

payload = {
    "emails": [],
    "name": ""
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/email-lists"

payload <- "{\n  \"emails\": [],\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/email-lists")

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

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"emails\": [],\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/email-lists') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"emails\": [],\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}}/email-lists";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "emails": [],
  "name": ""
}' |  \
  http POST {{baseUrl}}/email-lists \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "emails": [],\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/email-lists

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "emails": [],
  "name": ""
] as [String : Any]

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

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/email-lists/:id" {:headers {:ev-api-key ""
                                                                        :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/email-lists/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/email-lists/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/email-lists/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/email-lists/:id"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

DELETE /baseUrl/email-lists/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/email-lists/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/email-lists/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .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}}/email-lists/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/email-lists/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/email-lists/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/email-lists/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/email-lists/:id',
  method: 'DELETE',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/email-lists/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/email-lists/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/email-lists/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/email-lists/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email-lists/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/email-lists/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/email-lists/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/email-lists/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/email-lists/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email-lists/:id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email-lists/:id' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("DELETE", "/baseUrl/email-lists/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/email-lists/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/email-lists/:id"

response <- VERB("DELETE", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/email-lists/:id")

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

request = Net::HTTP::Delete.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/email-lists/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/email-lists/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method DELETE \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/email-lists/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/email-lists/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/email-lists");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/email-lists" {:headers {:ev-api-key ""
                                                                 :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/email-lists"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/email-lists"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/email-lists");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/email-lists"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/email-lists HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/email-lists")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/email-lists"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/email-lists")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/email-lists")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/email-lists');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/email-lists',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/email-lists';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/email-lists',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/email-lists")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/email-lists',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/email-lists',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/email-lists');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/email-lists',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/email-lists';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email-lists"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/email-lists" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/email-lists",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/email-lists', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/email-lists');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email-lists' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email-lists' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/email-lists", headers=headers)

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

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

import requests

url = "{{baseUrl}}/email-lists"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/email-lists"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/email-lists")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/email-lists') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/email-lists \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/email-lists

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/email-lists/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/email-lists/:id" {:headers {:ev-api-key ""
                                                                     :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/email-lists/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/email-lists/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/email-lists/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/email-lists/:id"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/email-lists/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/email-lists/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/email-lists/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/email-lists/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/email-lists/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/email-lists/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/email-lists/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/email-lists/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/email-lists/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/email-lists/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/email-lists/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/email-lists/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/email-lists/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/email-lists/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/email-lists/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/email-lists/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/email-lists/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/email-lists/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email-lists/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email-lists/:id' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/email-lists/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/email-lists/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/email-lists/:id"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/email-lists/:id")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/email-lists/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/email-lists/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/email-lists/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/email-lists/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/email-lists/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"emails\": [],\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/email-lists/:id" {:headers {:ev-api-key ""
                                                                       :ev-access-token ""}
                                                             :content-type :json
                                                             :form-params {:emails []
                                                                           :name ""}})

require "http/client"

url = "{{baseUrl}}/email-lists/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"emails\": [],\n  \"name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/email-lists/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"emails\": [],\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}}/email-lists/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"emails\": [],\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/email-lists/:id"

	payload := strings.NewReader("{\n  \"emails\": [],\n  \"name\": \"\"\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/email-lists/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "emails": [],
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/email-lists/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"emails\": [],\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/email-lists/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"emails\": [],\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  \"emails\": [],\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/email-lists/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/email-lists/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"emails\": [],\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  emails: [],
  name: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/email-lists/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {emails: [], name: ''}
};

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

const url = '{{baseUrl}}/email-lists/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"emails":[],"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}}/email-lists/:id',
  method: 'PATCH',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "emails": [],\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  \"emails\": [],\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/email-lists/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/email-lists/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({emails: [], name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {emails: [], name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/email-lists/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  emails: [],
  name: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/email-lists/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {emails: [], name: ''}
};

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

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

const url = '{{baseUrl}}/email-lists/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"emails":[],"name":""}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"emails": @[  ],
                              @"name": @"" };

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

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

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

 "{{baseUrl}}/email-lists/: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([
    'emails' => [
        
    ],
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/email-lists/:id', [
  'body' => '{
  "emails": [],
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'emails' => [
    
  ],
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/email-lists/:id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/email-lists/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "emails": [],
  "name": ""
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/email-lists/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "emails": [],
  "name": ""
}'

import http.client

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

payload = "{\n  \"emails\": [],\n  \"name\": \"\"\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("PATCH", "/baseUrl/email-lists/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/email-lists/:id"

payload = {
    "emails": [],
    "name": ""
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/email-lists/:id"

payload <- "{\n  \"emails\": [],\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/email-lists/:id")

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

request = Net::HTTP::Patch.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"emails\": [],\n  \"name\": \"\"\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/email-lists/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"emails\": [],\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

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

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "emails": [],
  "name": ""
}' |  \
  http PATCH {{baseUrl}}/email-lists/:id \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method PATCH \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "emails": [],\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/email-lists/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "emails": [],
  "name": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/email-lists/: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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/forms/entries/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/forms/entries/:id" {:headers {:ev-api-key ""
                                                                          :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/forms/entries/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/forms/entries/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/forms/entries/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/forms/entries/:id"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

DELETE /baseUrl/forms/entries/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/forms/entries/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/forms/entries/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .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}}/forms/entries/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/forms/entries/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/forms/entries/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/forms/entries/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/forms/entries/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/forms/entries/:id',
  method: 'DELETE',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/forms/entries/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/forms/entries/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/forms/entries/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/forms/entries/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/forms/entries/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/forms/entries/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/forms/entries/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/forms/entries/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/forms/entries/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/forms/entries/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/forms/entries/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/forms/entries/:id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/forms/entries/:id' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("DELETE", "/baseUrl/forms/entries/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/forms/entries/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/forms/entries/:id"

response <- VERB("DELETE", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/forms/entries/:id")

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

request = Net::HTTP::Delete.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/forms/entries/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/forms/entries/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method DELETE \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/forms/entries/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/forms/entries/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/forms/entries/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/forms/entries/:id" {:headers {:ev-api-key ""
                                                                       :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/forms/entries/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/forms/entries/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/forms/entries/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/forms/entries/:id"

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/forms/entries/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/forms/entries/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/forms/entries/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/forms/entries/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/forms/entries/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/forms/entries/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/forms/entries/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/forms/entries/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/forms/entries/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/forms/entries/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/forms/entries/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/forms/entries/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/forms/entries/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/forms/entries/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/forms/entries/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/forms/entries/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/forms/entries/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/forms/entries/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/forms/entries/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/forms/entries/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/forms/entries/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/forms/entries/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/forms/entries/:id' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/forms/entries/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/forms/entries/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/forms/entries/:id"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/forms/entries/:id")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/forms/entries/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/forms/entries/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/forms/entries/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/forms/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/forms/:id" {:headers {:ev-api-key ""
                                                               :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/forms/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/forms/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/forms/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/forms/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/forms/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/forms/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/forms/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/forms/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/forms/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/forms/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/forms/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/forms/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/forms/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/forms/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/forms/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/forms/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/forms/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/forms/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/forms/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/forms/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/forms/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/forms/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/forms/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/forms/:id' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/forms/:id", headers=headers)

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

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

import requests

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

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/forms/:id")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/forms/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/forms/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/forms/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/forms?shareHash=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/forms" {:headers {:ev-api-key ""
                                                           :ev-access-token ""}
                                                 :query-params {:shareHash ""}})

require "http/client"

url = "{{baseUrl}}/forms?shareHash="
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/forms?shareHash="),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/forms?shareHash=");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/forms?shareHash="

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/forms?shareHash= HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/forms?shareHash=")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/forms?shareHash="))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/forms?shareHash=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/forms?shareHash=")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/forms?shareHash=');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/forms',
  params: {shareHash: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/forms?shareHash=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/forms?shareHash=',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/forms?shareHash=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/forms?shareHash=',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/forms',
  qs: {shareHash: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/forms',
  params: {shareHash: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/forms?shareHash=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/forms?shareHash="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/forms?shareHash=" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/forms?shareHash=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/forms?shareHash=', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/forms?shareHash=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/forms?shareHash=' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/forms?shareHash=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/forms"

querystring = {"shareHash":""}

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

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

print(response.json())

library(httr)

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

queryString <- list(shareHash = "")

response <- VERB("GET", url, query = queryString, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/forms?shareHash=")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/forms') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.params['shareHash'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/forms?shareHash=' \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - '{{baseUrl}}/forms?shareHash='

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/forms/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/forms/:id" {:headers {:ev-api-key ""
                                                                 :ev-access-token ""}
                                                       :content-type :json
                                                       :form-params {:cssStyles ""
                                                                     :elements [{:id 0
                                                                                 :name ""
                                                                                 :order 0
                                                                                 :settings {:isRequired false
                                                                                            :senderEmail false
                                                                                            :useAsFolderName false}
                                                                                 :type ""}]
                                                                     :formDescription ""
                                                                     :submitButtonText ""
                                                                     :successMessage ""}})

require "http/client"

url = "{{baseUrl}}/forms/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\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}}/forms/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\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}}/forms/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/forms/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 318

{
  "cssStyles": "",
  "elements": [
    {
      "id": 0,
      "name": "",
      "order": 0,
      "settings": {
        "isRequired": false,
        "senderEmail": false,
        "useAsFolderName": false
      },
      "type": ""
    }
  ],
  "formDescription": "",
  "submitButtonText": "",
  "successMessage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/forms/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/forms/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\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  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/forms/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/forms/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cssStyles: '',
  elements: [
    {
      id: 0,
      name: '',
      order: 0,
      settings: {
        isRequired: false,
        senderEmail: false,
        useAsFolderName: false
      },
      type: ''
    }
  ],
  formDescription: '',
  submitButtonText: '',
  successMessage: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/forms/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/forms/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    cssStyles: '',
    elements: [
      {
        id: 0,
        name: '',
        order: 0,
        settings: {isRequired: false, senderEmail: false, useAsFolderName: false},
        type: ''
      }
    ],
    formDescription: '',
    submitButtonText: '',
    successMessage: ''
  }
};

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

const url = '{{baseUrl}}/forms/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"cssStyles":"","elements":[{"id":0,"name":"","order":0,"settings":{"isRequired":false,"senderEmail":false,"useAsFolderName":false},"type":""}],"formDescription":"","submitButtonText":"","successMessage":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/forms/:id',
  method: 'PATCH',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cssStyles": "",\n  "elements": [\n    {\n      "id": 0,\n      "name": "",\n      "order": 0,\n      "settings": {\n        "isRequired": false,\n        "senderEmail": false,\n        "useAsFolderName": false\n      },\n      "type": ""\n    }\n  ],\n  "formDescription": "",\n  "submitButtonText": "",\n  "successMessage": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/forms/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/forms/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({
  cssStyles: '',
  elements: [
    {
      id: 0,
      name: '',
      order: 0,
      settings: {isRequired: false, senderEmail: false, useAsFolderName: false},
      type: ''
    }
  ],
  formDescription: '',
  submitButtonText: '',
  successMessage: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/forms/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {
    cssStyles: '',
    elements: [
      {
        id: 0,
        name: '',
        order: 0,
        settings: {isRequired: false, senderEmail: false, useAsFolderName: false},
        type: ''
      }
    ],
    formDescription: '',
    submitButtonText: '',
    successMessage: ''
  },
  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}}/forms/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cssStyles: '',
  elements: [
    {
      id: 0,
      name: '',
      order: 0,
      settings: {
        isRequired: false,
        senderEmail: false,
        useAsFolderName: false
      },
      type: ''
    }
  ],
  formDescription: '',
  submitButtonText: '',
  successMessage: ''
});

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}}/forms/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    cssStyles: '',
    elements: [
      {
        id: 0,
        name: '',
        order: 0,
        settings: {isRequired: false, senderEmail: false, useAsFolderName: false},
        type: ''
      }
    ],
    formDescription: '',
    submitButtonText: '',
    successMessage: ''
  }
};

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

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

const url = '{{baseUrl}}/forms/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"cssStyles":"","elements":[{"id":0,"name":"","order":0,"settings":{"isRequired":false,"senderEmail":false,"useAsFolderName":false},"type":""}],"formDescription":"","submitButtonText":"","successMessage":""}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cssStyles": @"",
                              @"elements": @[ @{ @"id": @0, @"name": @"", @"order": @0, @"settings": @{ @"isRequired": @NO, @"senderEmail": @NO, @"useAsFolderName": @NO }, @"type": @"" } ],
                              @"formDescription": @"",
                              @"submitButtonText": @"",
                              @"successMessage": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/forms/: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}}/forms/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}" in

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

 "{{baseUrl}}/forms/: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([
    'cssStyles' => '',
    'elements' => [
        [
                'id' => 0,
                'name' => '',
                'order' => 0,
                'settings' => [
                                'isRequired' => null,
                                'senderEmail' => null,
                                'useAsFolderName' => null
                ],
                'type' => ''
        ]
    ],
    'formDescription' => '',
    'submitButtonText' => '',
    'successMessage' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/forms/:id', [
  'body' => '{
  "cssStyles": "",
  "elements": [
    {
      "id": 0,
      "name": "",
      "order": 0,
      "settings": {
        "isRequired": false,
        "senderEmail": false,
        "useAsFolderName": false
      },
      "type": ""
    }
  ],
  "formDescription": "",
  "submitButtonText": "",
  "successMessage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cssStyles' => '',
  'elements' => [
    [
        'id' => 0,
        'name' => '',
        'order' => 0,
        'settings' => [
                'isRequired' => null,
                'senderEmail' => null,
                'useAsFolderName' => null
        ],
        'type' => ''
    ]
  ],
  'formDescription' => '',
  'submitButtonText' => '',
  'successMessage' => ''
]));

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

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

append(json_encode([
  'cssStyles' => '',
  'elements' => [
    [
        'id' => 0,
        'name' => '',
        'order' => 0,
        'settings' => [
                'isRequired' => null,
                'senderEmail' => null,
                'useAsFolderName' => null
        ],
        'type' => ''
    ]
  ],
  'formDescription' => '',
  'submitButtonText' => '',
  'successMessage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/forms/:id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/forms/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "cssStyles": "",
  "elements": [
    {
      "id": 0,
      "name": "",
      "order": 0,
      "settings": {
        "isRequired": false,
        "senderEmail": false,
        "useAsFolderName": false
      },
      "type": ""
    }
  ],
  "formDescription": "",
  "submitButtonText": "",
  "successMessage": ""
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/forms/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "cssStyles": "",
  "elements": [
    {
      "id": 0,
      "name": "",
      "order": 0,
      "settings": {
        "isRequired": false,
        "senderEmail": false,
        "useAsFolderName": false
      },
      "type": ""
    }
  ],
  "formDescription": "",
  "submitButtonText": "",
  "successMessage": ""
}'

import http.client

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

payload = "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("PATCH", "/baseUrl/forms/:id", payload, headers)

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

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

import requests

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

payload = {
    "cssStyles": "",
    "elements": [
        {
            "id": 0,
            "name": "",
            "order": 0,
            "settings": {
                "isRequired": False,
                "senderEmail": False,
                "useAsFolderName": False
            },
            "type": ""
        }
    ],
    "formDescription": "",
    "submitButtonText": "",
    "successMessage": ""
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/forms/:id")

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

request = Net::HTTP::Patch.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\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/forms/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"cssStyles\": \"\",\n  \"elements\": [\n    {\n      \"id\": 0,\n      \"name\": \"\",\n      \"order\": 0,\n      \"settings\": {\n        \"isRequired\": false,\n        \"senderEmail\": false,\n        \"useAsFolderName\": false\n      },\n      \"type\": \"\"\n    }\n  ],\n  \"formDescription\": \"\",\n  \"submitButtonText\": \"\",\n  \"successMessage\": \"\"\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}}/forms/:id";

    let payload = json!({
        "cssStyles": "",
        "elements": (
            json!({
                "id": 0,
                "name": "",
                "order": 0,
                "settings": json!({
                    "isRequired": false,
                    "senderEmail": false,
                    "useAsFolderName": false
                }),
                "type": ""
            })
        ),
        "formDescription": "",
        "submitButtonText": "",
        "successMessage": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "cssStyles": "",
  "elements": [
    {
      "id": 0,
      "name": "",
      "order": 0,
      "settings": {
        "isRequired": false,
        "senderEmail": false,
        "useAsFolderName": false
      },
      "type": ""
    }
  ],
  "formDescription": "",
  "submitButtonText": "",
  "successMessage": ""
}' |  \
  http PATCH {{baseUrl}}/forms/:id \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method PATCH \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "cssStyles": "",\n  "elements": [\n    {\n      "id": 0,\n      "name": "",\n      "order": 0,\n      "settings": {\n        "isRequired": false,\n        "senderEmail": false,\n        "useAsFolderName": false\n      },\n      "type": ""\n    }\n  ],\n  "formDescription": "",\n  "submitButtonText": "",\n  "successMessage": ""\n}' \
  --output-document \
  - {{baseUrl}}/forms/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "cssStyles": "",
  "elements": [
    [
      "id": 0,
      "name": "",
      "order": 0,
      "settings": [
        "isRequired": false,
        "senderEmail": false,
        "useAsFolderName": false
      ],
      "type": ""
    ]
  ],
  "formDescription": "",
  "submitButtonText": "",
  "successMessage": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/notifications" {:headers {:ev-api-key ""
                                                                    :ev-access-token ""}
                                                          :content-type :json
                                                          :form-params {:action ""
                                                                        :message ""
                                                                        :recipients []
                                                                        :resource ""
                                                                        :sendEmail false
                                                                        :type ""
                                                                        :usernames []}})

require "http/client"

url = "{{baseUrl}}/notifications"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\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}}/notifications"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\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}}/notifications");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/notifications HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 128

{
  "action": "",
  "message": "",
  "recipients": [],
  "resource": "",
  "sendEmail": false,
  "type": "",
  "usernames": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/notifications")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/notifications")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/notifications")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}")
  .asString();

const data = JSON.stringify({
  action: '',
  message: '',
  recipients: [],
  resource: '',
  sendEmail: false,
  type: '',
  usernames: []
});

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

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

xhr.open('POST', '{{baseUrl}}/notifications');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/notifications',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    action: '',
    message: '',
    recipients: [],
    resource: '',
    sendEmail: false,
    type: '',
    usernames: []
  }
};

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

const url = '{{baseUrl}}/notifications';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"action":"","message":"","recipients":[],"resource":"","sendEmail":false,"type":"","usernames":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "action": "",\n  "message": "",\n  "recipients": [],\n  "resource": "",\n  "sendEmail": false,\n  "type": "",\n  "usernames": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/notifications")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/notifications',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  action: '',
  message: '',
  recipients: [],
  resource: '',
  sendEmail: false,
  type: '',
  usernames: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/notifications',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {
    action: '',
    message: '',
    recipients: [],
    resource: '',
    sendEmail: false,
    type: '',
    usernames: []
  },
  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}}/notifications');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  action: '',
  message: '',
  recipients: [],
  resource: '',
  sendEmail: false,
  type: '',
  usernames: []
});

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}}/notifications',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    action: '',
    message: '',
    recipients: [],
    resource: '',
    sendEmail: false,
    type: '',
    usernames: []
  }
};

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

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

const url = '{{baseUrl}}/notifications';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"action":"","message":"","recipients":[],"resource":"","sendEmail":false,"type":"","usernames":[]}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"action": @"",
                              @"message": @"",
                              @"recipients": @[  ],
                              @"resource": @"",
                              @"sendEmail": @NO,
                              @"type": @"",
                              @"usernames": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications"]
                                                       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}}/notifications" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}" in

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

 "{{baseUrl}}/notifications",
  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([
    'action' => '',
    'message' => '',
    'recipients' => [
        
    ],
    'resource' => '',
    'sendEmail' => null,
    'type' => '',
    'usernames' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/notifications', [
  'body' => '{
  "action": "",
  "message": "",
  "recipients": [],
  "resource": "",
  "sendEmail": false,
  "type": "",
  "usernames": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'action' => '',
  'message' => '',
  'recipients' => [
    
  ],
  'resource' => '',
  'sendEmail' => null,
  'type' => '',
  'usernames' => [
    
  ]
]));

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

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

append(json_encode([
  'action' => '',
  'message' => '',
  'recipients' => [
    
  ],
  'resource' => '',
  'sendEmail' => null,
  'type' => '',
  'usernames' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/notifications');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "message": "",
  "recipients": [],
  "resource": "",
  "sendEmail": false,
  "type": "",
  "usernames": []
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "message": "",
  "recipients": [],
  "resource": "",
  "sendEmail": false,
  "type": "",
  "usernames": []
}'

import http.client

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

payload = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/notifications"

payload = {
    "action": "",
    "message": "",
    "recipients": [],
    "resource": "",
    "sendEmail": False,
    "type": "",
    "usernames": []
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\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/notifications') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"resource\": \"\",\n  \"sendEmail\": false,\n  \"type\": \"\",\n  \"usernames\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "action": "",
        "message": "",
        "recipients": (),
        "resource": "",
        "sendEmail": false,
        "type": "",
        "usernames": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "action": "",
  "message": "",
  "recipients": [],
  "resource": "",
  "sendEmail": false,
  "type": "",
  "usernames": []
}' |  \
  http POST {{baseUrl}}/notifications \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "action": "",\n  "message": "",\n  "recipients": [],\n  "resource": "",\n  "sendEmail": false,\n  "type": "",\n  "usernames": []\n}' \
  --output-document \
  - {{baseUrl}}/notifications

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "action": "",
  "message": "",
  "recipients": [],
  "resource": "",
  "sendEmail": false,
  "type": "",
  "usernames": []
] as [String : Any]

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

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/notifications/:id" {:headers {:ev-api-key ""
                                                                          :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/notifications/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/notifications/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/notifications/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

DELETE /baseUrl/notifications/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/notifications/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .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}}/notifications/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/notifications/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/notifications/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/notifications/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications/:id',
  method: 'DELETE',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/notifications/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/notifications/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/notifications/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/notifications/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/notifications/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications/:id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications/:id' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("DELETE", "/baseUrl/notifications/:id", headers=headers)

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

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

import requests

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

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("DELETE", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications/:id")

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

request = Net::HTTP::Delete.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/notifications/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/notifications/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method DELETE \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/notifications/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/notifications");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/notifications" {:headers {:ev-api-key ""
                                                                   :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/notifications"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/notifications"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/notifications");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/notifications HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/notifications")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/notifications")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/notifications")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/notifications');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/notifications',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/notifications';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/notifications")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/notifications',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/notifications',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/notifications';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/notifications",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/notifications', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/notifications');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/notifications", headers=headers)

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

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

import requests

url = "{{baseUrl}}/notifications"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/notifications') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/notifications \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/notifications

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/notifications/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/notifications/:id" {:headers {:ev-api-key ""
                                                                       :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/notifications/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/notifications/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/notifications/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

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

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

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

}

GET /baseUrl/notifications/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/notifications/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/notifications/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/notifications/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

const url = '{{baseUrl}}/notifications/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/notifications/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

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

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

const url = '{{baseUrl}}/notifications/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/notifications/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

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

 "{{baseUrl}}/notifications/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/notifications/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/notifications/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications/:id' -Method GET -Headers $headers

import http.client

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

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/notifications/:id", headers=headers)

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

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

import requests

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

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications/:id")

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

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/notifications/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

http GET {{baseUrl}}/notifications/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/notifications/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/notifications/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/notifications/:id" {:headers {:ev-api-key ""
                                                                         :ev-access-token ""}
                                                               :content-type :json
                                                               :form-params {:action ""
                                                                             :message ""
                                                                             :recipients []
                                                                             :sendEmail false
                                                                             :usernames []}})

require "http/client"

url = "{{baseUrl}}/notifications/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\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}}/notifications/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\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}}/notifications/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/notifications/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 96

{
  "action": "",
  "message": "",
  "recipients": [],
  "sendEmail": false,
  "usernames": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/notifications/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/notifications/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/notifications/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}")
  .asString();

const data = JSON.stringify({
  action: '',
  message: '',
  recipients: [],
  sendEmail: false,
  usernames: []
});

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

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

xhr.open('PATCH', '{{baseUrl}}/notifications/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {action: '', message: '', recipients: [], sendEmail: false, usernames: []}
};

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

const url = '{{baseUrl}}/notifications/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"action":"","message":"","recipients":[],"sendEmail":false,"usernames":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/notifications/:id',
  method: 'PATCH',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "action": "",\n  "message": "",\n  "recipients": [],\n  "sendEmail": false,\n  "usernames": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/notifications/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/notifications/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({action: '', message: '', recipients: [], sendEmail: false, usernames: []}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {action: '', message: '', recipients: [], sendEmail: false, usernames: []},
  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}}/notifications/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  action: '',
  message: '',
  recipients: [],
  sendEmail: false,
  usernames: []
});

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}}/notifications/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {action: '', message: '', recipients: [], sendEmail: false, usernames: []}
};

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

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

const url = '{{baseUrl}}/notifications/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"action":"","message":"","recipients":[],"sendEmail":false,"usernames":[]}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"action": @"",
                              @"message": @"",
                              @"recipients": @[  ],
                              @"sendEmail": @NO,
                              @"usernames": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/notifications/: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}}/notifications/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}" in

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

 "{{baseUrl}}/notifications/: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([
    'action' => '',
    'message' => '',
    'recipients' => [
        
    ],
    'sendEmail' => null,
    'usernames' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/notifications/:id', [
  'body' => '{
  "action": "",
  "message": "",
  "recipients": [],
  "sendEmail": false,
  "usernames": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'action' => '',
  'message' => '',
  'recipients' => [
    
  ],
  'sendEmail' => null,
  'usernames' => [
    
  ]
]));

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

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

append(json_encode([
  'action' => '',
  'message' => '',
  'recipients' => [
    
  ],
  'sendEmail' => null,
  'usernames' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/notifications/:id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/notifications/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "message": "",
  "recipients": [],
  "sendEmail": false,
  "usernames": []
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/notifications/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "message": "",
  "recipients": [],
  "sendEmail": false,
  "usernames": []
}'

import http.client

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

payload = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("PATCH", "/baseUrl/notifications/:id", payload, headers)

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

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

import requests

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

payload = {
    "action": "",
    "message": "",
    "recipients": [],
    "sendEmail": False,
    "usernames": []
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/notifications/:id")

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

request = Net::HTTP::Patch.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\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/notifications/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"action\": \"\",\n  \"message\": \"\",\n  \"recipients\": [],\n  \"sendEmail\": false,\n  \"usernames\": []\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}}/notifications/:id";

    let payload = json!({
        "action": "",
        "message": "",
        "recipients": (),
        "sendEmail": false,
        "usernames": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "action": "",
  "message": "",
  "recipients": [],
  "sendEmail": false,
  "usernames": []
}' |  \
  http PATCH {{baseUrl}}/notifications/:id \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method PATCH \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "action": "",\n  "message": "",\n  "recipients": [],\n  "sendEmail": false,\n  "usernames": []\n}' \
  --output-document \
  - {{baseUrl}}/notifications/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "action": "",
  "message": "",
  "recipients": [],
  "sendEmail": false,
  "usernames": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/notifications/: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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/recipients/shares/invites/:shareId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"recipientId\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/recipients/shares/invites/:shareId" {:headers {:ev-api-key ""
                                                                                         :ev-access-token ""}
                                                                               :content-type :json
                                                                               :form-params {:recipientId 0}})

require "http/client"

url = "{{baseUrl}}/recipients/shares/invites/:shareId"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"recipientId\": 0\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/recipients/shares/invites/:shareId"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"recipientId\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/recipients/shares/invites/:shareId");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"recipientId\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/recipients/shares/invites/:shareId"

	payload := strings.NewReader("{\n  \"recipientId\": 0\n}")

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

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/recipients/shares/invites/:shareId HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "recipientId": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/recipients/shares/invites/:shareId")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"recipientId\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/recipients/shares/invites/:shareId"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"recipientId\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"recipientId\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/recipients/shares/invites/:shareId")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/recipients/shares/invites/:shareId")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"recipientId\": 0\n}")
  .asString();

const data = JSON.stringify({
  recipientId: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/recipients/shares/invites/:shareId');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/recipients/shares/invites/:shareId',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {recipientId: 0}
};

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

const url = '{{baseUrl}}/recipients/shares/invites/:shareId';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"recipientId":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/recipients/shares/invites/:shareId',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "recipientId": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"recipientId\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/recipients/shares/invites/:shareId")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/recipients/shares/invites/:shareId',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({recipientId: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/recipients/shares/invites/:shareId',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {recipientId: 0},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/recipients/shares/invites/:shareId');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/recipients/shares/invites/:shareId',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {recipientId: 0}
};

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

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

const url = '{{baseUrl}}/recipients/shares/invites/:shareId';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"recipientId":0}'
};

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

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"recipientId": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/recipients/shares/invites/:shareId"]
                                                       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}}/recipients/shares/invites/:shareId" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"recipientId\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/recipients/shares/invites/:shareId",
  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([
    'recipientId' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/recipients/shares/invites/:shareId', [
  'body' => '{
  "recipientId": 0
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/recipients/shares/invites/:shareId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'recipientId' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'recipientId' => 0
]));
$request->setRequestUrl('{{baseUrl}}/recipients/shares/invites/:shareId');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/recipients/shares/invites/:shareId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "recipientId": 0
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/recipients/shares/invites/:shareId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "recipientId": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"recipientId\": 0\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/recipients/shares/invites/:shareId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/recipients/shares/invites/:shareId"

payload = { "recipientId": 0 }
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/recipients/shares/invites/:shareId"

payload <- "{\n  \"recipientId\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/recipients/shares/invites/:shareId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"recipientId\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/recipients/shares/invites/:shareId') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"recipientId\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/recipients/shares/invites/:shareId";

    let payload = json!({"recipientId": 0});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "recipientId": 0
}' |  \
  http POST {{baseUrl}}/recipients/shares/invites/:shareId \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "recipientId": 0\n}' \
  --output-document \
  - {{baseUrl}}/recipients/shares/invites/:shareId

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = ["recipientId": 0] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/recipients/shares/invites/:shareId")! 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}}/resources/compress");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resources/compress" {:headers {:ev-api-key ""
                                                                         :ev-access-token ""}
                                                               :content-type :json
                                                               :form-params {:archiveName ""
                                                                             :parentResource ""
                                                                             :resources []}})

require "http/client"

url = "{{baseUrl}}/resources/compress"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\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}}/resources/compress"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\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}}/resources/compress");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/compress"

	payload := strings.NewReader("{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/resources/compress HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "archiveName": "",
  "parentResource": "",
  "resources": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resources/compress")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/compress"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\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  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/compress")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resources/compress")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
  .asString();

const data = JSON.stringify({
  archiveName: '',
  parentResource: '',
  resources: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resources/compress');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/compress',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {archiveName: '', parentResource: '', resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/compress';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"archiveName":"","parentResource":"","resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/compress',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "archiveName": "",\n  "parentResource": "",\n  "resources": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources/compress")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/resources/compress',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({archiveName: '', parentResource: '', resources: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/compress',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {archiveName: '', parentResource: '', resources: []},
  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}}/resources/compress');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  archiveName: '',
  parentResource: '',
  resources: []
});

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}}/resources/compress',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {archiveName: '', parentResource: '', resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/compress';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"archiveName":"","parentResource":"","resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"archiveName": @"",
                              @"parentResource": @"",
                              @"resources": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/compress"]
                                                       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}}/resources/compress" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/compress",
  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([
    'archiveName' => '',
    'parentResource' => '',
    'resources' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resources/compress', [
  'body' => '{
  "archiveName": "",
  "parentResource": "",
  "resources": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/compress');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'archiveName' => '',
  'parentResource' => '',
  'resources' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'archiveName' => '',
  'parentResource' => '',
  'resources' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resources/compress');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/compress' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "archiveName": "",
  "parentResource": "",
  "resources": []
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/compress' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "archiveName": "",
  "parentResource": "",
  "resources": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/resources/compress", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/compress"

payload = {
    "archiveName": "",
    "parentResource": "",
    "resources": []
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/compress"

payload <- "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/compress")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\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/resources/compress') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"archiveName\": \"\",\n  \"parentResource\": \"\",\n  \"resources\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/compress";

    let payload = json!({
        "archiveName": "",
        "parentResource": "",
        "resources": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "archiveName": "",
  "parentResource": "",
  "resources": []
}' |  \
  http POST {{baseUrl}}/resources/compress \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "archiveName": "",\n  "parentResource": "",\n  "resources": []\n}' \
  --output-document \
  - {{baseUrl}}/resources/compress

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "archiveName": "",
  "parentResource": "",
  "resources": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/compress")! 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}}/resources/copy");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resources/copy" {:headers {:ev-api-key ""
                                                                     :ev-access-token ""}
                                                           :content-type :json
                                                           :form-params {:parentResource ""
                                                                         :resources []}})

require "http/client"

url = "{{baseUrl}}/resources/copy"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"parentResource\": \"\",\n  \"resources\": []\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}}/resources/copy"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"parentResource\": \"\",\n  \"resources\": []\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}}/resources/copy");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/copy"

	payload := strings.NewReader("{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/resources/copy HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "parentResource": "",
  "resources": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resources/copy")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/copy"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"parentResource\": \"\",\n  \"resources\": []\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  \"parentResource\": \"\",\n  \"resources\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/copy")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resources/copy")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
  .asString();

const data = JSON.stringify({
  parentResource: '',
  resources: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resources/copy');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/copy',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {parentResource: '', resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/copy';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"parentResource":"","resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/copy',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "parentResource": "",\n  "resources": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources/copy")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/resources/copy',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({parentResource: '', resources: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/copy',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {parentResource: '', resources: []},
  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}}/resources/copy');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  parentResource: '',
  resources: []
});

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}}/resources/copy',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {parentResource: '', resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/copy';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"parentResource":"","resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"parentResource": @"",
                              @"resources": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/copy"]
                                                       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}}/resources/copy" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/copy",
  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([
    'parentResource' => '',
    'resources' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resources/copy', [
  'body' => '{
  "parentResource": "",
  "resources": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/copy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'parentResource' => '',
  'resources' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'parentResource' => '',
  'resources' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resources/copy');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentResource": "",
  "resources": []
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentResource": "",
  "resources": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/resources/copy", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/copy"

payload = {
    "parentResource": "",
    "resources": []
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/copy"

payload <- "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/copy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"parentResource\": \"\",\n  \"resources\": []\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/resources/copy') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/copy";

    let payload = json!({
        "parentResource": "",
        "resources": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "parentResource": "",
  "resources": []
}' |  \
  http POST {{baseUrl}}/resources/copy \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "parentResource": "",\n  "resources": []\n}' \
  --output-document \
  - {{baseUrl}}/resources/copy

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "parentResource": "",
  "resources": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/copy")! 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}}/resources");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resources" {:headers {:ev-api-key ""
                                                                :ev-access-token ""}
                                                      :content-type :json
                                                      :form-params {:name ""
                                                                    :parentResource ""
                                                                    :path ""}})

require "http/client"

url = "{{baseUrl}}/resources"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\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}}/resources"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\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}}/resources");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/resources HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "name": "",
  "parentResource": "",
  "path": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resources")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\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  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resources")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  parentResource: '',
  path: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resources');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {name: '', parentResource: '', path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"name":"","parentResource":"","path":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "parentResource": "",\n  "path": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/resources',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({name: '', parentResource: '', path: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {name: '', parentResource: '', path: ''},
  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}}/resources');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  parentResource: '',
  path: ''
});

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}}/resources',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {name: '', parentResource: '', path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"name":"","parentResource":"","path":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"parentResource": @"",
                              @"path": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources"]
                                                       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}}/resources" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources",
  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([
    'name' => '',
    'parentResource' => '',
    'path' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resources', [
  'body' => '{
  "name": "",
  "parentResource": "",
  "path": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'parentResource' => '',
  'path' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'parentResource' => '',
  'path' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resources');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "parentResource": "",
  "path": ""
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "parentResource": "",
  "path": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/resources", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources"

payload = {
    "name": "",
    "parentResource": "",
    "path": ""
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources"

payload <- "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\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/resources') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"parentResource\": \"\",\n  \"path\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources";

    let payload = json!({
        "name": "",
        "parentResource": "",
        "path": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "name": "",
  "parentResource": "",
  "path": ""
}' |  \
  http POST {{baseUrl}}/resources \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "parentResource": "",\n  "path": ""\n}' \
  --output-document \
  - {{baseUrl}}/resources

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "parentResource": "",
  "path": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources")! 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}}/resources");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resources\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/resources" {:headers {:ev-api-key ""
                                                                  :ev-access-token ""}
                                                        :content-type :json
                                                        :form-params {:resources []}})

require "http/client"

url = "{{baseUrl}}/resources"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"resources\": []\n}"

response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/resources"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"resources\": []\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}}/resources");
var request = new RestRequest("", Method.Delete);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resources\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources"

	payload := strings.NewReader("{\n  \"resources\": []\n}")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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))

}

DELETE /baseUrl/resources HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "resources": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/resources")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resources\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("{\n  \"resources\": []\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  \"resources\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources")
  .delete(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/resources")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"resources\": []\n}")
  .asString();

const data = JSON.stringify({
  resources: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/resources');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resources',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources';
const options = {
  method: 'DELETE',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources',
  method: 'DELETE',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resources": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resources\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources")
  .delete(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({resources: []}));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resources',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {resources: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resources');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resources: []
});

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}}/resources',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources';
const options = {
  method: 'DELETE',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resources": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/resources" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"resources\": []\n}" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    'resources' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/resources', [
  'body' => '{
  "resources": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resources' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resources' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resources');
$request->setRequestMethod('DELETE');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "resources": []
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "resources": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resources\": []\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("DELETE", "/baseUrl/resources", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources"

payload = { "resources": [] }
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources"

payload <- "{\n  \"resources\": []\n}"

encode <- "json"

response <- VERB("DELETE", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"resources\": []\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.delete('/baseUrl/resources') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"resources\": []\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}}/resources";

    let payload = json!({"resources": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "resources": []
}' |  \
  http DELETE {{baseUrl}}/resources \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method DELETE \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resources": []\n}' \
  --output-document \
  - {{baseUrl}}/resources

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = ["resources": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/resources/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/resources/:id" {:headers {:ev-api-key ""
                                                                      :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/resources/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/resources/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/resources/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/resources/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .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}}/resources/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/resources/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/resources/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resources/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/:id',
  method: 'DELETE',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/resources/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resources/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resources/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/resources/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:id' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("DELETE", "/baseUrl/resources/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:id"

response <- VERB("DELETE", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/resources/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/resources/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method DELETE \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/resources/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/resources/download?resources%5B%5D=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/download" {:headers {:ev-api-key ""
                                                                        :ev-access-token ""}
                                                              :query-params {:resources[] ""}})

require "http/client"

url = "{{baseUrl}}/resources/download?resources%5B%5D="
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources/download?resources%5B%5D="),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/download?resources%5B%5D=");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/download?resources%5B%5D="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources/download?resources%5B%5D= HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/download?resources%5B%5D=")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/download?resources%5B%5D="))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/download?resources%5B%5D=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/download?resources%5B%5D=")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources/download?resources%5B%5D=');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/download',
  params: {'resources[]': ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/download?resources%5B%5D=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/download?resources%5B%5D=',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/download?resources%5B%5D=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/download?resources%5B%5D=',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/resources/download',
  qs: {'resources[]': ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/download');

req.query({
  'resources[]': ''
});

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/download',
  params: {'resources[]': ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/download?resources%5B%5D=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/download?resources%5B%5D="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/download?resources%5B%5D=" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/download?resources%5B%5D=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources/download?resources%5B%5D=', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/download');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resources[]' => ''
]);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/download');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resources[]' => ''
]));

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/download?resources%5B%5D=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/download?resources%5B%5D=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/resources/download?resources%5B%5D=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/download"

querystring = {"resources[]":""}

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/download"

queryString <- list(resources[] = "")

response <- VERB("GET", url, query = queryString, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/download?resources%5B%5D=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources/download') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.params['resources[]'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/download";

    let querystring = [
        ("resources[]", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/resources/download?resources%5B%5D=' \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - '{{baseUrl}}/resources/download?resources%5B%5D='

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/download?resources%5B%5D=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/resources/extract");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resources/extract" {:headers {:ev-api-key ""
                                                                        :ev-access-token ""}
                                                              :content-type :json
                                                              :form-params {:parentResource ""
                                                                            :resource ""}})

require "http/client"

url = "{{baseUrl}}/resources/extract"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\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}}/resources/extract"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\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}}/resources/extract");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/extract"

	payload := strings.NewReader("{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/resources/extract HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "parentResource": "",
  "resource": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resources/extract")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/extract"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\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  \"parentResource\": \"\",\n  \"resource\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/extract")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resources/extract")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  parentResource: '',
  resource: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resources/extract');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/extract',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {parentResource: '', resource: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/extract';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"parentResource":"","resource":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/extract',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "parentResource": "",\n  "resource": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources/extract")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/resources/extract',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({parentResource: '', resource: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/extract',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {parentResource: '', resource: ''},
  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}}/resources/extract');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  parentResource: '',
  resource: ''
});

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}}/resources/extract',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {parentResource: '', resource: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/extract';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"parentResource":"","resource":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"parentResource": @"",
                              @"resource": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/extract"]
                                                       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}}/resources/extract" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/extract",
  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([
    'parentResource' => '',
    'resource' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resources/extract', [
  'body' => '{
  "parentResource": "",
  "resource": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/extract');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'parentResource' => '',
  'resource' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'parentResource' => '',
  'resource' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resources/extract');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/extract' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentResource": "",
  "resource": ""
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/extract' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentResource": "",
  "resource": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/resources/extract", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/extract"

payload = {
    "parentResource": "",
    "resource": ""
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/extract"

payload <- "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/extract")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\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/resources/extract') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"parentResource\": \"\",\n  \"resource\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/extract";

    let payload = json!({
        "parentResource": "",
        "resource": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "parentResource": "",
  "resource": ""
}' |  \
  http POST {{baseUrl}}/resources/extract \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "parentResource": "",\n  "resource": ""\n}' \
  --output-document \
  - {{baseUrl}}/resources/extract

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "parentResource": "",
  "resource": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/extract")! 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}}/resources?resource=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources" {:headers {:ev-api-key ""
                                                               :ev-access-token ""}
                                                     :query-params {:resource ""}})

require "http/client"

url = "{{baseUrl}}/resources?resource="
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources?resource="),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources?resource=");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources?resource="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources?resource= HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources?resource=")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources?resource="))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources?resource=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources?resource=")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources?resource=');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources',
  params: {resource: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources?resource=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources?resource=',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources?resource=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources?resource=',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/resources',
  qs: {resource: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources');

req.query({
  resource: ''
});

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources',
  params: {resource: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources?resource=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources?resource="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources?resource=" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources?resource=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources?resource=', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resource' => ''
]);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resource' => ''
]));

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources?resource=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources?resource=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/resources?resource=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources"

querystring = {"resource":""}

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources"

queryString <- list(resource = "")

response <- VERB("GET", url, query = queryString, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources?resource=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.params['resource'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources";

    let querystring = [
        ("resource", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/resources?resource=' \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - '{{baseUrl}}/resources?resource='

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources?resource=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/resources/list?resource=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/list" {:headers {:ev-api-key ""
                                                                    :ev-access-token ""}
                                                          :query-params {:resource ""}})

require "http/client"

url = "{{baseUrl}}/resources/list?resource="
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources/list?resource="),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/list?resource=");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/list?resource="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources/list?resource= HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/list?resource=")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/list?resource="))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/list?resource=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/list?resource=")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources/list?resource=');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/list',
  params: {resource: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/list?resource=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/list?resource=',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/list?resource=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/list?resource=',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/resources/list',
  qs: {resource: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/list');

req.query({
  resource: ''
});

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/list',
  params: {resource: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/list?resource=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/list?resource="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/list?resource=" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/list?resource=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources/list?resource=', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/list');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resource' => ''
]);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/list');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resource' => ''
]));

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/list?resource=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/list?resource=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/resources/list?resource=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/list"

querystring = {"resource":""}

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/list"

queryString <- list(resource = "")

response <- VERB("GET", url, query = queryString, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/list?resource=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources/list') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.params['resource'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/list";

    let querystring = [
        ("resource", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/resources/list?resource=' \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - '{{baseUrl}}/resources/list?resource='

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/list?resource=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/resources/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/:id" {:headers {:ev-api-key ""
                                                                   :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/resources/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/:id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/resources/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/resources/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:id"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/resources/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/resources/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/resources/list/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/list/:id" {:headers {:ev-api-key ""
                                                                        :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/resources/list/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources/list/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/list/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/list/:id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources/list/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/list/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/list/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/list/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/list/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources/list/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/list/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/list/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/list/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/list/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/list/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/resources/list/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/list/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/list/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/list/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/list/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/list/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/list/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources/list/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/list/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/list/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/list/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/list/:id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/resources/list/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/list/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/list/:id"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/list/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources/list/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/list/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/resources/list/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/resources/list/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/list/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/resources/move");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resources/move" {:headers {:ev-api-key ""
                                                                     :ev-access-token ""}
                                                           :content-type :json
                                                           :form-params {:parentResource ""
                                                                         :resources []}})

require "http/client"

url = "{{baseUrl}}/resources/move"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"parentResource\": \"\",\n  \"resources\": []\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}}/resources/move"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"parentResource\": \"\",\n  \"resources\": []\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}}/resources/move");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/move"

	payload := strings.NewReader("{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/resources/move HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "parentResource": "",
  "resources": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resources/move")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/move"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"parentResource\": \"\",\n  \"resources\": []\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  \"parentResource\": \"\",\n  \"resources\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/move")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resources/move")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
  .asString();

const data = JSON.stringify({
  parentResource: '',
  resources: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resources/move');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/move',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {parentResource: '', resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/move';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"parentResource":"","resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/move',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "parentResource": "",\n  "resources": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources/move")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/resources/move',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({parentResource: '', resources: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/move',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {parentResource: '', resources: []},
  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}}/resources/move');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  parentResource: '',
  resources: []
});

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}}/resources/move',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {parentResource: '', resources: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/move';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"parentResource":"","resources":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"parentResource": @"",
                              @"resources": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/move"]
                                                       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}}/resources/move" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/move",
  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([
    'parentResource' => '',
    'resources' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resources/move', [
  'body' => '{
  "parentResource": "",
  "resources": []
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/move');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'parentResource' => '',
  'resources' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'parentResource' => '',
  'resources' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resources/move');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/move' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentResource": "",
  "resources": []
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/move' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentResource": "",
  "resources": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/resources/move", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/move"

payload = {
    "parentResource": "",
    "resources": []
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/move"

payload <- "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/move")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"parentResource\": \"\",\n  \"resources\": []\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/resources/move') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"parentResource\": \"\",\n  \"resources\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/move";

    let payload = json!({
        "parentResource": "",
        "resources": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "parentResource": "",
  "resources": []
}' |  \
  http POST {{baseUrl}}/resources/move \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "parentResource": "",\n  "resources": []\n}' \
  --output-document \
  - {{baseUrl}}/resources/move

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "parentResource": "",
  "resources": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/move")! 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}}/resources/preview?resource=&size=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/preview" {:headers {:ev-api-key ""
                                                                       :ev-access-token ""}
                                                             :query-params {:resource ""
                                                                            :size ""}})

require "http/client"

url = "{{baseUrl}}/resources/preview?resource=&size="
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources/preview?resource=&size="),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/preview?resource=&size=");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/preview?resource=&size="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources/preview?resource=&size= HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/preview?resource=&size=")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/preview?resource=&size="))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/preview?resource=&size=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/preview?resource=&size=")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources/preview?resource=&size=');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/preview',
  params: {resource: '', size: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/preview?resource=&size=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/preview?resource=&size=',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/preview?resource=&size=")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/preview?resource=&size=',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/resources/preview',
  qs: {resource: '', size: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/preview');

req.query({
  resource: '',
  size: ''
});

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/preview',
  params: {resource: '', size: ''},
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/preview?resource=&size=';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/preview?resource=&size="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/preview?resource=&size=" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/preview?resource=&size=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources/preview?resource=&size=', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/preview');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'resource' => '',
  'size' => ''
]);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/preview');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'resource' => '',
  'size' => ''
]));

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/preview?resource=&size=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/preview?resource=&size=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/resources/preview?resource=&size=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/preview"

querystring = {"resource":"","size":""}

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/preview"

queryString <- list(
  resource = "",
  size = ""
)

response <- VERB("GET", url, query = queryString, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/preview?resource=&size=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources/preview') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.params['resource'] = ''
  req.params['size'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/preview";

    let querystring = [
        ("resource", ""),
        ("size", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/resources/preview?resource=&size=' \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - '{{baseUrl}}/resources/preview?resource=&size='

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/preview?resource=&size=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/resources/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/resources/:id" {:headers {:ev-access-token ""
                                                                     :ev-api-key ""}
                                                           :content-type :json
                                                           :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/resources/:id"
headers = HTTP::Headers{
  "ev-access-token" => ""
  "ev-api-key" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/resources/:id"),
    Headers =
    {
        { "ev-access-token", "" },
        { "ev-api-key", "" },
    },
    Content = new StringContent("{\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}}/resources/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("ev-access-token", "");
request.AddHeader("ev-api-key", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/:id"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("ev-access-token", "")
	req.Header.Add("ev-api-key", "")
	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/resources/:id HTTP/1.1
Ev-Access-Token: 
Ev-Api-Key: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/resources/:id")
  .setHeader("ev-access-token", "")
  .setHeader("ev-api-key", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/:id"))
    .header("ev-access-token", "")
    .header("ev-api-key", "")
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\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  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/:id")
  .patch(body)
  .addHeader("ev-access-token", "")
  .addHeader("ev-api-key", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/resources/:id")
  .header("ev-access-token", "")
  .header("ev-api-key", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/resources/:id');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resources/:id',
  headers: {'ev-access-token': '', 'ev-api-key': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-access-token': '', 'ev-api-key': '', 'content-type': 'application/json'},
  body: '{"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}}/resources/:id',
  method: 'PATCH',
  headers: {
    'ev-access-token': '',
    'ev-api-key': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\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  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resources/:id")
  .patch(body)
  .addHeader("ev-access-token", "")
  .addHeader("ev-api-key", "")
  .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/resources/:id',
  headers: {
    'ev-access-token': '',
    'ev-api-key': '',
    '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({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resources/:id',
  headers: {'ev-access-token': '', 'ev-api-key': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/resources/:id');

req.headers({
  'ev-access-token': '',
  'ev-api-key': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resources/:id',
  headers: {'ev-access-token': '', 'ev-api-key': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-access-token': '', 'ev-api-key': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-access-token": @"",
                           @"ev-api-key": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/: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}}/resources/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-access-token", "");
  ("ev-api-key", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/: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([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/resources/:id', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'ev-access-token' => '',
  'ev-api-key' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resources/:id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'ev-access-token' => '',
  'ev-api-key' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-access-token", "")
$headers.Add("ev-api-key", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("ev-access-token", "")
$headers.Add("ev-api-key", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'ev-access-token': "",
    'ev-api-key': "",
    'content-type': "application/json"
}

conn.request("PATCH", "/baseUrl/resources/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/:id"

payload = { "name": "" }
headers = {
    "ev-access-token": "",
    "ev-api-key": "",
    "content-type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:id"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, add_headers('ev-access-token' = '', 'ev-api-key' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["ev-access-token"] = ''
request["ev-api-key"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/resources/:id') do |req|
  req.headers['ev-access-token'] = ''
  req.headers['ev-api-key'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/:id";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-access-token", "".parse().unwrap());
    headers.insert("ev-api-key", "".parse().unwrap());
    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 '{
  "name": ""
}' |  \
  http PATCH {{baseUrl}}/resources/:id \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method PATCH \
  --header 'ev-access-token: ' \
  --header 'ev-api-key: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/resources/:id

import Foundation

let headers = [
  "ev-access-token": "",
  "ev-api-key": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/: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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resources/upload?path=&fileSize=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resources/upload" {:headers {:ev-api-key ""
                                                                       :ev-access-token ""}
                                                             :query-params {:path ""
                                                                            :fileSize ""}
                                                             :multipart [{:name "file"
                                                                          :content ""}]})

require "http/client"

url = "{{baseUrl}}/resources/upload?path=&fileSize="
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/resources/upload?path=&fileSize="),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "file",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/upload?path=&fileSize=");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/upload?path=&fileSize="

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/resources/upload?path=&fileSize= HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 113

-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resources/upload?path=&fileSize=")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/upload?path=&fileSize="))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/upload?path=&fileSize=")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resources/upload?path=&fileSize=")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('file', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resources/upload?path=&fileSize=');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('file', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/upload',
  params: {path: '', fileSize: ''},
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/upload?path=&fileSize=';
const form = new FormData();
form.append('file', '');

const options = {method: 'POST', headers: {'ev-api-key': '', 'ev-access-token': ''}};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const form = new FormData();
form.append('file', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/upload?path=&fileSize=',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  },
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/resources/upload?path=&fileSize=")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/upload?path=&fileSize=',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write('-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/upload',
  qs: {path: '', fileSize: ''},
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  formData: {file: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/resources/upload');

req.query({
  path: '',
  fileSize: ''
});

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resources/upload',
  params: {path: '', fileSize: ''},
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('file', '');

const url = '{{baseUrl}}/resources/upload?path=&fileSize=';
const options = {method: 'POST', headers: {'ev-api-key': '', 'ev-access-token': ''}};
options.body = formData;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"file", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/upload?path=&fileSize="]
                                                       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}}/resources/upload?path=&fileSize=" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "multipart/form-data; boundary=---011000010111000001101001");
] in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/upload?path=&fileSize=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resources/upload?path=&fileSize=', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resources/upload');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'path' => '',
  'fileSize' => ''
]);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/resources/upload');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'path' => '',
  'fileSize' => ''
]));

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/upload?path=&fileSize=' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/upload?path=&fileSize=' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001--
'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "multipart/form-data; boundary=---011000010111000001101001"
}

conn.request("POST", "/baseUrl/resources/upload?path=&fileSize=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/upload"

querystring = {"path":"","fileSize":""}

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "multipart/form-data; boundary=---011000010111000001101001"
}

response = requests.post(url, data=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/upload"

queryString <- list(
  path = "",
  fileSize = ""
)

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, query = queryString, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/upload?path=&fileSize=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/resources/upload') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.params['path'] = ''
  req.params['fileSize'] = ''
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/upload";

    let querystring = [
        ("path", ""),
        ("fileSize", ""),
    ];

    let form = reqwest::multipart::Form::new()
        .text("file", "");
    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001--
' |  \
  http POST '{{baseUrl}}/resources/upload?path=&fileSize=' \
  content-type:'multipart/form-data; boundary=---011000010111000001101001' \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - '{{baseUrl}}/resources/upload?path=&fileSize='

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "multipart/form-data; boundary=---011000010111000001101001"
]
let parameters = [
  [
    "name": "file",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/upload?path=&fileSize=")! 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}}/shares/complete-send/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/shares/complete-send/:id" {:headers {:ev-api-key ""
                                                                               :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/shares/complete-send/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/shares/complete-send/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/shares/complete-send/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/shares/complete-send/:id"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/shares/complete-send/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/shares/complete-send/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/shares/complete-send/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/shares/complete-send/:id")
  .post(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/shares/complete-send/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/shares/complete-send/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/shares/complete-send/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/shares/complete-send/:id';
const options = {method: 'POST', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/shares/complete-send/:id',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/shares/complete-send/:id")
  .post(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/shares/complete-send/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/shares/complete-send/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/shares/complete-send/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/shares/complete-send/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/shares/complete-send/:id';
const options = {method: 'POST', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/shares/complete-send/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/shares/complete-send/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/shares/complete-send/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/shares/complete-send/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/shares/complete-send/:id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/shares/complete-send/:id');
$request->setRequestMethod('POST');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/shares/complete-send/:id' -Method POST -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/shares/complete-send/:id' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("POST", "/baseUrl/shares/complete-send/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/shares/complete-send/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/shares/complete-send/:id"

response <- VERB("POST", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/shares/complete-send/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/shares/complete-send/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/shares/complete-send/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/shares/complete-send/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/shares/complete-send/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/shares/complete-send/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/shares");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/shares" {:headers {:ev-api-key ""
                                                             :ev-access-token ""}
                                                   :content-type :json
                                                   :form-params {:accessMode {:delete false
                                                                              :download false
                                                                              :modify false
                                                                              :upload false}
                                                                 :embed false
                                                                 :expiration ""
                                                                 :fileDropCreateFolders false
                                                                 :hasNotification false
                                                                 :isPublic false
                                                                 :messageBody ""
                                                                 :messageSubject ""
                                                                 :name ""
                                                                 :notificationEmails []
                                                                 :password ""
                                                                 :recipients [{:email ""
                                                                               :type ""}]
                                                                 :requireEmail false
                                                                 :resources []
                                                                 :sendingLocalFiles false
                                                                 :type ""}})

require "http/client"

url = "{{baseUrl}}/shares"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\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}}/shares"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\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}}/shares");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/shares"

	payload := strings.NewReader("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/shares HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 495

{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "sendingLocalFiles": false,
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/shares")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/shares"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\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  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/shares")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/shares")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  accessMode: {
    delete: false,
    download: false,
    modify: false,
    upload: false
  },
  embed: false,
  expiration: '',
  fileDropCreateFolders: false,
  hasNotification: false,
  isPublic: false,
  messageBody: '',
  messageSubject: '',
  name: '',
  notificationEmails: [],
  password: '',
  recipients: [
    {
      email: '',
      type: ''
    }
  ],
  requireEmail: false,
  resources: [],
  sendingLocalFiles: false,
  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}}/shares');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/shares',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    accessMode: {delete: false, download: false, modify: false, upload: false},
    embed: false,
    expiration: '',
    fileDropCreateFolders: false,
    hasNotification: false,
    isPublic: false,
    messageBody: '',
    messageSubject: '',
    name: '',
    notificationEmails: [],
    password: '',
    recipients: [{email: '', type: ''}],
    requireEmail: false,
    resources: [],
    sendingLocalFiles: false,
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/shares';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"accessMode":{"delete":false,"download":false,"modify":false,"upload":false},"embed":false,"expiration":"","fileDropCreateFolders":false,"hasNotification":false,"isPublic":false,"messageBody":"","messageSubject":"","name":"","notificationEmails":[],"password":"","recipients":[{"email":"","type":""}],"requireEmail":false,"resources":[],"sendingLocalFiles":false,"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}}/shares',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accessMode": {\n    "delete": false,\n    "download": false,\n    "modify": false,\n    "upload": false\n  },\n  "embed": false,\n  "expiration": "",\n  "fileDropCreateFolders": false,\n  "hasNotification": false,\n  "isPublic": false,\n  "messageBody": "",\n  "messageSubject": "",\n  "name": "",\n  "notificationEmails": [],\n  "password": "",\n  "recipients": [\n    {\n      "email": "",\n      "type": ""\n    }\n  ],\n  "requireEmail": false,\n  "resources": [],\n  "sendingLocalFiles": false,\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  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/shares")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/shares',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({
  accessMode: {delete: false, download: false, modify: false, upload: false},
  embed: false,
  expiration: '',
  fileDropCreateFolders: false,
  hasNotification: false,
  isPublic: false,
  messageBody: '',
  messageSubject: '',
  name: '',
  notificationEmails: [],
  password: '',
  recipients: [{email: '', type: ''}],
  requireEmail: false,
  resources: [],
  sendingLocalFiles: false,
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/shares',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {
    accessMode: {delete: false, download: false, modify: false, upload: false},
    embed: false,
    expiration: '',
    fileDropCreateFolders: false,
    hasNotification: false,
    isPublic: false,
    messageBody: '',
    messageSubject: '',
    name: '',
    notificationEmails: [],
    password: '',
    recipients: [{email: '', type: ''}],
    requireEmail: false,
    resources: [],
    sendingLocalFiles: false,
    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}}/shares');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  accessMode: {
    delete: false,
    download: false,
    modify: false,
    upload: false
  },
  embed: false,
  expiration: '',
  fileDropCreateFolders: false,
  hasNotification: false,
  isPublic: false,
  messageBody: '',
  messageSubject: '',
  name: '',
  notificationEmails: [],
  password: '',
  recipients: [
    {
      email: '',
      type: ''
    }
  ],
  requireEmail: false,
  resources: [],
  sendingLocalFiles: false,
  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}}/shares',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    accessMode: {delete: false, download: false, modify: false, upload: false},
    embed: false,
    expiration: '',
    fileDropCreateFolders: false,
    hasNotification: false,
    isPublic: false,
    messageBody: '',
    messageSubject: '',
    name: '',
    notificationEmails: [],
    password: '',
    recipients: [{email: '', type: ''}],
    requireEmail: false,
    resources: [],
    sendingLocalFiles: false,
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/shares';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"accessMode":{"delete":false,"download":false,"modify":false,"upload":false},"embed":false,"expiration":"","fileDropCreateFolders":false,"hasNotification":false,"isPublic":false,"messageBody":"","messageSubject":"","name":"","notificationEmails":[],"password":"","recipients":[{"email":"","type":""}],"requireEmail":false,"resources":[],"sendingLocalFiles":false,"type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"accessMode": @{ @"delete": @NO, @"download": @NO, @"modify": @NO, @"upload": @NO },
                              @"embed": @NO,
                              @"expiration": @"",
                              @"fileDropCreateFolders": @NO,
                              @"hasNotification": @NO,
                              @"isPublic": @NO,
                              @"messageBody": @"",
                              @"messageSubject": @"",
                              @"name": @"",
                              @"notificationEmails": @[  ],
                              @"password": @"",
                              @"recipients": @[ @{ @"email": @"", @"type": @"" } ],
                              @"requireEmail": @NO,
                              @"resources": @[  ],
                              @"sendingLocalFiles": @NO,
                              @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/shares"]
                                                       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}}/shares" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/shares",
  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([
    'accessMode' => [
        'delete' => null,
        'download' => null,
        'modify' => null,
        'upload' => null
    ],
    'embed' => null,
    'expiration' => '',
    'fileDropCreateFolders' => null,
    'hasNotification' => null,
    'isPublic' => null,
    'messageBody' => '',
    'messageSubject' => '',
    'name' => '',
    'notificationEmails' => [
        
    ],
    'password' => '',
    'recipients' => [
        [
                'email' => '',
                'type' => ''
        ]
    ],
    'requireEmail' => null,
    'resources' => [
        
    ],
    'sendingLocalFiles' => null,
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/shares', [
  'body' => '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "sendingLocalFiles": false,
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/shares');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accessMode' => [
    'delete' => null,
    'download' => null,
    'modify' => null,
    'upload' => null
  ],
  'embed' => null,
  'expiration' => '',
  'fileDropCreateFolders' => null,
  'hasNotification' => null,
  'isPublic' => null,
  'messageBody' => '',
  'messageSubject' => '',
  'name' => '',
  'notificationEmails' => [
    
  ],
  'password' => '',
  'recipients' => [
    [
        'email' => '',
        'type' => ''
    ]
  ],
  'requireEmail' => null,
  'resources' => [
    
  ],
  'sendingLocalFiles' => null,
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'accessMode' => [
    'delete' => null,
    'download' => null,
    'modify' => null,
    'upload' => null
  ],
  'embed' => null,
  'expiration' => '',
  'fileDropCreateFolders' => null,
  'hasNotification' => null,
  'isPublic' => null,
  'messageBody' => '',
  'messageSubject' => '',
  'name' => '',
  'notificationEmails' => [
    
  ],
  'password' => '',
  'recipients' => [
    [
        'email' => '',
        'type' => ''
    ]
  ],
  'requireEmail' => null,
  'resources' => [
    
  ],
  'sendingLocalFiles' => null,
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/shares');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/shares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "sendingLocalFiles": false,
  "type": ""
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/shares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "sendingLocalFiles": false,
  "type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/shares", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/shares"

payload = {
    "accessMode": {
        "delete": False,
        "download": False,
        "modify": False,
        "upload": False
    },
    "embed": False,
    "expiration": "",
    "fileDropCreateFolders": False,
    "hasNotification": False,
    "isPublic": False,
    "messageBody": "",
    "messageSubject": "",
    "name": "",
    "notificationEmails": [],
    "password": "",
    "recipients": [
        {
            "email": "",
            "type": ""
        }
    ],
    "requireEmail": False,
    "resources": [],
    "sendingLocalFiles": False,
    "type": ""
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/shares"

payload <- "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/shares")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\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/shares') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"sendingLocalFiles\": false,\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}}/shares";

    let payload = json!({
        "accessMode": json!({
            "delete": false,
            "download": false,
            "modify": false,
            "upload": false
        }),
        "embed": false,
        "expiration": "",
        "fileDropCreateFolders": false,
        "hasNotification": false,
        "isPublic": false,
        "messageBody": "",
        "messageSubject": "",
        "name": "",
        "notificationEmails": (),
        "password": "",
        "recipients": (
            json!({
                "email": "",
                "type": ""
            })
        ),
        "requireEmail": false,
        "resources": (),
        "sendingLocalFiles": false,
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "sendingLocalFiles": false,
  "type": ""
}' |  \
  http POST {{baseUrl}}/shares \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accessMode": {\n    "delete": false,\n    "download": false,\n    "modify": false,\n    "upload": false\n  },\n  "embed": false,\n  "expiration": "",\n  "fileDropCreateFolders": false,\n  "hasNotification": false,\n  "isPublic": false,\n  "messageBody": "",\n  "messageSubject": "",\n  "name": "",\n  "notificationEmails": [],\n  "password": "",\n  "recipients": [\n    {\n      "email": "",\n      "type": ""\n    }\n  ],\n  "requireEmail": false,\n  "resources": [],\n  "sendingLocalFiles": false,\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/shares

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "accessMode": [
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  ],
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    [
      "email": "",
      "type": ""
    ]
  ],
  "requireEmail": false,
  "resources": [],
  "sendingLocalFiles": false,
  "type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/shares")! 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}}/shares/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/shares/:id" {:headers {:ev-api-key ""
                                                                   :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/shares/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/shares/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/shares/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/shares/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/shares/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/shares/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/shares/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .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}}/shares/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/shares/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/shares/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/shares/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/shares/:id',
  method: 'DELETE',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/shares/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/shares/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/shares/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/shares/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/shares/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/shares/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/shares/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/shares/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/shares/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/shares/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/shares/:id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/shares/:id' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("DELETE", "/baseUrl/shares/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/shares/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/shares/:id"

response <- VERB("DELETE", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/shares/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/shares/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/shares/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/shares/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method DELETE \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/shares/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/shares/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/shares");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/shares" {:headers {:ev-api-key ""
                                                            :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/shares"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/shares"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/shares");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/shares"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/shares HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/shares")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/shares"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/shares")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/shares")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/shares');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/shares',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/shares';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/shares',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/shares")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/shares',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/shares',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/shares');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/shares',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/shares';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/shares"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/shares" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/shares",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/shares', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/shares');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/shares');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/shares' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/shares' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/shares", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/shares"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/shares"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/shares")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/shares') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/shares";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/shares \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/shares

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/shares")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/shares/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/shares/:id" {:headers {:ev-api-key ""
                                                                :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/shares/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/shares/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/shares/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/shares/:id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/shares/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/shares/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/shares/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/shares/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/shares/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/shares/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/shares/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/shares/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/shares/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/shares/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/shares/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/shares/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/shares/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/shares/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/shares/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/shares/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/shares/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/shares/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/shares/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/shares/:id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/shares/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/shares/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/shares/:id"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/shares/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/shares/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/shares/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/shares/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/shares/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/shares/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/shares/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/shares/:id" {:headers {:ev-api-key ""
                                                                  :ev-access-token ""}
                                                        :content-type :json
                                                        :form-params {:accessMode {:delete false
                                                                                   :download false
                                                                                   :modify false
                                                                                   :upload false}
                                                                      :embed false
                                                                      :expiration ""
                                                                      :fileDropCreateFolders false
                                                                      :hasNotification false
                                                                      :isPublic false
                                                                      :messageBody ""
                                                                      :messageSubject ""
                                                                      :name ""
                                                                      :notificationEmails []
                                                                      :password ""
                                                                      :recipients [{:email ""
                                                                                    :type ""}]
                                                                      :requireEmail false
                                                                      :resources []
                                                                      :status 0}})

require "http/client"

url = "{{baseUrl}}/shares/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\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}}/shares/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/shares/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/shares/:id"

	payload := strings.NewReader("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/shares/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 466

{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "status": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/shares/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/shares/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/shares/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/shares/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}")
  .asString();

const data = JSON.stringify({
  accessMode: {
    delete: false,
    download: false,
    modify: false,
    upload: false
  },
  embed: false,
  expiration: '',
  fileDropCreateFolders: false,
  hasNotification: false,
  isPublic: false,
  messageBody: '',
  messageSubject: '',
  name: '',
  notificationEmails: [],
  password: '',
  recipients: [
    {
      email: '',
      type: ''
    }
  ],
  requireEmail: false,
  resources: [],
  status: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/shares/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    accessMode: {delete: false, download: false, modify: false, upload: false},
    embed: false,
    expiration: '',
    fileDropCreateFolders: false,
    hasNotification: false,
    isPublic: false,
    messageBody: '',
    messageSubject: '',
    name: '',
    notificationEmails: [],
    password: '',
    recipients: [{email: '', type: ''}],
    requireEmail: false,
    resources: [],
    status: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/shares/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"accessMode":{"delete":false,"download":false,"modify":false,"upload":false},"embed":false,"expiration":"","fileDropCreateFolders":false,"hasNotification":false,"isPublic":false,"messageBody":"","messageSubject":"","name":"","notificationEmails":[],"password":"","recipients":[{"email":"","type":""}],"requireEmail":false,"resources":[],"status":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/shares/:id',
  method: 'PATCH',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accessMode": {\n    "delete": false,\n    "download": false,\n    "modify": false,\n    "upload": false\n  },\n  "embed": false,\n  "expiration": "",\n  "fileDropCreateFolders": false,\n  "hasNotification": false,\n  "isPublic": false,\n  "messageBody": "",\n  "messageSubject": "",\n  "name": "",\n  "notificationEmails": [],\n  "password": "",\n  "recipients": [\n    {\n      "email": "",\n      "type": ""\n    }\n  ],\n  "requireEmail": false,\n  "resources": [],\n  "status": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/shares/:id")
  .patch(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/shares/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({
  accessMode: {delete: false, download: false, modify: false, upload: false},
  embed: false,
  expiration: '',
  fileDropCreateFolders: false,
  hasNotification: false,
  isPublic: false,
  messageBody: '',
  messageSubject: '',
  name: '',
  notificationEmails: [],
  password: '',
  recipients: [{email: '', type: ''}],
  requireEmail: false,
  resources: [],
  status: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {
    accessMode: {delete: false, download: false, modify: false, upload: false},
    embed: false,
    expiration: '',
    fileDropCreateFolders: false,
    hasNotification: false,
    isPublic: false,
    messageBody: '',
    messageSubject: '',
    name: '',
    notificationEmails: [],
    password: '',
    recipients: [{email: '', type: ''}],
    requireEmail: false,
    resources: [],
    status: 0
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/shares/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  accessMode: {
    delete: false,
    download: false,
    modify: false,
    upload: false
  },
  embed: false,
  expiration: '',
  fileDropCreateFolders: false,
  hasNotification: false,
  isPublic: false,
  messageBody: '',
  messageSubject: '',
  name: '',
  notificationEmails: [],
  password: '',
  recipients: [
    {
      email: '',
      type: ''
    }
  ],
  requireEmail: false,
  resources: [],
  status: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/shares/:id',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {
    accessMode: {delete: false, download: false, modify: false, upload: false},
    embed: false,
    expiration: '',
    fileDropCreateFolders: false,
    hasNotification: false,
    isPublic: false,
    messageBody: '',
    messageSubject: '',
    name: '',
    notificationEmails: [],
    password: '',
    recipients: [{email: '', type: ''}],
    requireEmail: false,
    resources: [],
    status: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/shares/:id';
const options = {
  method: 'PATCH',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"accessMode":{"delete":false,"download":false,"modify":false,"upload":false},"embed":false,"expiration":"","fileDropCreateFolders":false,"hasNotification":false,"isPublic":false,"messageBody":"","messageSubject":"","name":"","notificationEmails":[],"password":"","recipients":[{"email":"","type":""}],"requireEmail":false,"resources":[],"status":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"accessMode": @{ @"delete": @NO, @"download": @NO, @"modify": @NO, @"upload": @NO },
                              @"embed": @NO,
                              @"expiration": @"",
                              @"fileDropCreateFolders": @NO,
                              @"hasNotification": @NO,
                              @"isPublic": @NO,
                              @"messageBody": @"",
                              @"messageSubject": @"",
                              @"name": @"",
                              @"notificationEmails": @[  ],
                              @"password": @"",
                              @"recipients": @[ @{ @"email": @"", @"type": @"" } ],
                              @"requireEmail": @NO,
                              @"resources": @[  ],
                              @"status": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/shares/: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}}/shares/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/shares/: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([
    'accessMode' => [
        'delete' => null,
        'download' => null,
        'modify' => null,
        'upload' => null
    ],
    'embed' => null,
    'expiration' => '',
    'fileDropCreateFolders' => null,
    'hasNotification' => null,
    'isPublic' => null,
    'messageBody' => '',
    'messageSubject' => '',
    'name' => '',
    'notificationEmails' => [
        
    ],
    'password' => '',
    'recipients' => [
        [
                'email' => '',
                'type' => ''
        ]
    ],
    'requireEmail' => null,
    'resources' => [
        
    ],
    'status' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/shares/:id', [
  'body' => '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "status": 0
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/shares/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accessMode' => [
    'delete' => null,
    'download' => null,
    'modify' => null,
    'upload' => null
  ],
  'embed' => null,
  'expiration' => '',
  'fileDropCreateFolders' => null,
  'hasNotification' => null,
  'isPublic' => null,
  'messageBody' => '',
  'messageSubject' => '',
  'name' => '',
  'notificationEmails' => [
    
  ],
  'password' => '',
  'recipients' => [
    [
        'email' => '',
        'type' => ''
    ]
  ],
  'requireEmail' => null,
  'resources' => [
    
  ],
  'status' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'accessMode' => [
    'delete' => null,
    'download' => null,
    'modify' => null,
    'upload' => null
  ],
  'embed' => null,
  'expiration' => '',
  'fileDropCreateFolders' => null,
  'hasNotification' => null,
  'isPublic' => null,
  'messageBody' => '',
  'messageSubject' => '',
  'name' => '',
  'notificationEmails' => [
    
  ],
  'password' => '',
  'recipients' => [
    [
        'email' => '',
        'type' => ''
    ]
  ],
  'requireEmail' => null,
  'resources' => [
    
  ],
  'status' => 0
]));
$request->setRequestUrl('{{baseUrl}}/shares/:id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/shares/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "status": 0
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/shares/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "status": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("PATCH", "/baseUrl/shares/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/shares/:id"

payload = {
    "accessMode": {
        "delete": False,
        "download": False,
        "modify": False,
        "upload": False
    },
    "embed": False,
    "expiration": "",
    "fileDropCreateFolders": False,
    "hasNotification": False,
    "isPublic": False,
    "messageBody": "",
    "messageSubject": "",
    "name": "",
    "notificationEmails": [],
    "password": "",
    "recipients": [
        {
            "email": "",
            "type": ""
        }
    ],
    "requireEmail": False,
    "resources": [],
    "status": 0
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/shares/:id"

payload <- "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/shares/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/shares/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"accessMode\": {\n    \"delete\": false,\n    \"download\": false,\n    \"modify\": false,\n    \"upload\": false\n  },\n  \"embed\": false,\n  \"expiration\": \"\",\n  \"fileDropCreateFolders\": false,\n  \"hasNotification\": false,\n  \"isPublic\": false,\n  \"messageBody\": \"\",\n  \"messageSubject\": \"\",\n  \"name\": \"\",\n  \"notificationEmails\": [],\n  \"password\": \"\",\n  \"recipients\": [\n    {\n      \"email\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"requireEmail\": false,\n  \"resources\": [],\n  \"status\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/shares/:id";

    let payload = json!({
        "accessMode": json!({
            "delete": false,
            "download": false,
            "modify": false,
            "upload": false
        }),
        "embed": false,
        "expiration": "",
        "fileDropCreateFolders": false,
        "hasNotification": false,
        "isPublic": false,
        "messageBody": "",
        "messageSubject": "",
        "name": "",
        "notificationEmails": (),
        "password": "",
        "recipients": (
            json!({
                "email": "",
                "type": ""
            })
        ),
        "requireEmail": false,
        "resources": (),
        "status": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "accessMode": {
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  },
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    {
      "email": "",
      "type": ""
    }
  ],
  "requireEmail": false,
  "resources": [],
  "status": 0
}' |  \
  http PATCH {{baseUrl}}/shares/:id \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method PATCH \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accessMode": {\n    "delete": false,\n    "download": false,\n    "modify": false,\n    "upload": false\n  },\n  "embed": false,\n  "expiration": "",\n  "fileDropCreateFolders": false,\n  "hasNotification": false,\n  "isPublic": false,\n  "messageBody": "",\n  "messageSubject": "",\n  "name": "",\n  "notificationEmails": [],\n  "password": "",\n  "recipients": [\n    {\n      "email": "",\n      "type": ""\n    }\n  ],\n  "requireEmail": false,\n  "resources": [],\n  "status": 0\n}' \
  --output-document \
  - {{baseUrl}}/shares/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "accessMode": [
    "delete": false,
    "download": false,
    "modify": false,
    "upload": false
  ],
  "embed": false,
  "expiration": "",
  "fileDropCreateFolders": false,
  "hasNotification": false,
  "isPublic": false,
  "messageBody": "",
  "messageSubject": "",
  "name": "",
  "notificationEmails": [],
  "password": "",
  "recipients": [
    [
      "email": "",
      "type": ""
    ]
  ],
  "requireEmail": false,
  "resources": [],
  "status": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/shares/: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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ssh-keys");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/ssh-keys" {:headers {:ev-api-key ""
                                                               :ev-access-token ""}
                                                     :content-type :json
                                                     :form-params {:publicKey ""
                                                                   :userId 0}})

require "http/client"

url = "{{baseUrl}}/ssh-keys"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/ssh-keys"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
    Content = new StringContent("{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ssh-keys");
var request = new RestRequest("", Method.Post);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ssh-keys"

	payload := strings.NewReader("{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")
	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/ssh-keys HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "publicKey": "",
  "userId": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ssh-keys")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ssh-keys"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ssh-keys")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/ssh-keys")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .header("content-type", "application/json")
  .body("{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}")
  .asString();

const data = JSON.stringify({
  publicKey: '',
  userId: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/ssh-keys');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ssh-keys',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {publicKey: '', userId: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ssh-keys';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"publicKey":"","userId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ssh-keys',
  method: 'POST',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "publicKey": "",\n  "userId": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ssh-keys")
  .post(body)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .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/ssh-keys',
  headers: {
    'ev-api-key': '',
    'ev-access-token': '',
    '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({publicKey: '', userId: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ssh-keys',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: {publicKey: '', userId: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/ssh-keys');

req.headers({
  'ev-api-key': '',
  'ev-access-token': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  publicKey: '',
  userId: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ssh-keys',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  data: {publicKey: '', userId: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ssh-keys';
const options = {
  method: 'POST',
  headers: {'ev-api-key': '', 'ev-access-token': '', 'content-type': 'application/json'},
  body: '{"publicKey":"","userId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"publicKey": @"",
                              @"userId": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ssh-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}}/ssh-keys" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ssh-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([
    'publicKey' => '',
    'userId' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/ssh-keys', [
  'body' => '{
  "publicKey": "",
  "userId": 0
}',
  'headers' => [
    'content-type' => 'application/json',
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ssh-keys');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'publicKey' => '',
  'userId' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'publicKey' => '',
  'userId' => 0
]));
$request->setRequestUrl('{{baseUrl}}/ssh-keys');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ssh-keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "publicKey": "",
  "userId": 0
}'

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ssh-keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "publicKey": "",
  "userId": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}"

headers = {
    'ev-api-key': "",
    'ev-access-token': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/ssh-keys", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ssh-keys"

payload = {
    "publicKey": "",
    "userId": 0
}
headers = {
    "ev-api-key": "",
    "ev-access-token": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ssh-keys"

payload <- "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ssh-keys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/ssh-keys') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
  req.body = "{\n  \"publicKey\": \"\",\n  \"userId\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ssh-keys";

    let payload = json!({
        "publicKey": "",
        "userId": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());
    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 '{
  "publicKey": "",
  "userId": 0
}' |  \
  http POST {{baseUrl}}/ssh-keys \
  content-type:application/json \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method POST \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "publicKey": "",\n  "userId": 0\n}' \
  --output-document \
  - {{baseUrl}}/ssh-keys

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": "",
  "content-type": "application/json"
]
let parameters = [
  "publicKey": "",
  "userId": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ssh-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}}/ssh-keys/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/ssh-keys/:id" {:headers {:ev-api-key ""
                                                                     :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/ssh-keys/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/ssh-keys/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ssh-keys/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ssh-keys/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/ssh-keys/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/ssh-keys/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ssh-keys/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .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}}/ssh-keys/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/ssh-keys/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/ssh-keys/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/ssh-keys/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ssh-keys/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ssh-keys/:id',
  method: 'DELETE',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ssh-keys/:id")
  .delete(null)
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ssh-keys/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/ssh-keys/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/ssh-keys/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/ssh-keys/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ssh-keys/:id';
const options = {method: 'DELETE', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ssh-keys/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ssh-keys/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ssh-keys/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/ssh-keys/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ssh-keys/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ssh-keys/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ssh-keys/:id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ssh-keys/:id' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("DELETE", "/baseUrl/ssh-keys/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ssh-keys/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ssh-keys/:id"

response <- VERB("DELETE", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ssh-keys/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/ssh-keys/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ssh-keys/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/ssh-keys/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method DELETE \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/ssh-keys/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ssh-keys/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/ssh-keys");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ssh-keys" {:headers {:ev-api-key ""
                                                              :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/ssh-keys"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ssh-keys"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ssh-keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ssh-keys"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ssh-keys HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ssh-keys")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ssh-keys"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ssh-keys")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ssh-keys")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ssh-keys');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ssh-keys',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ssh-keys';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ssh-keys',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ssh-keys")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ssh-keys',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/ssh-keys',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ssh-keys');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ssh-keys',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ssh-keys';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ssh-keys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ssh-keys" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ssh-keys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ssh-keys', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ssh-keys');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ssh-keys');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ssh-keys' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ssh-keys' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/ssh-keys", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ssh-keys"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ssh-keys"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ssh-keys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ssh-keys') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ssh-keys";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/ssh-keys \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/ssh-keys

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ssh-keys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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}}/ssh-keys/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "ev-api-key: ");
headers = curl_slist_append(headers, "ev-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ssh-keys/:id" {:headers {:ev-api-key ""
                                                                  :ev-access-token ""}})

require "http/client"

url = "{{baseUrl}}/ssh-keys/:id"
headers = HTTP::Headers{
  "ev-api-key" => ""
  "ev-access-token" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ssh-keys/:id"),
    Headers =
    {
        { "ev-api-key", "" },
        { "ev-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ssh-keys/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("ev-api-key", "");
request.AddHeader("ev-access-token", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ssh-keys/:id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("ev-api-key", "")
	req.Header.Add("ev-access-token", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ssh-keys/:id HTTP/1.1
Ev-Api-Key: 
Ev-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ssh-keys/:id")
  .setHeader("ev-api-key", "")
  .setHeader("ev-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ssh-keys/:id"))
    .header("ev-api-key", "")
    .header("ev-access-token", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ssh-keys/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ssh-keys/:id")
  .header("ev-api-key", "")
  .header("ev-access-token", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ssh-keys/:id');
xhr.setRequestHeader('ev-api-key', '');
xhr.setRequestHeader('ev-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ssh-keys/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ssh-keys/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ssh-keys/:id',
  method: 'GET',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ssh-keys/:id")
  .get()
  .addHeader("ev-api-key", "")
  .addHeader("ev-access-token", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ssh-keys/:id',
  headers: {
    'ev-api-key': '',
    'ev-access-token': ''
  }
};

const req = http.request(options, function (res) {
  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}}/ssh-keys/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ssh-keys/:id');

req.headers({
  'ev-api-key': '',
  'ev-access-token': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ssh-keys/:id',
  headers: {'ev-api-key': '', 'ev-access-token': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ssh-keys/:id';
const options = {method: 'GET', headers: {'ev-api-key': '', 'ev-access-token': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"ev-api-key": @"",
                           @"ev-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ssh-keys/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ssh-keys/:id" in
let headers = Header.add_list (Header.init ()) [
  ("ev-api-key", "");
  ("ev-access-token", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ssh-keys/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "ev-access-token: ",
    "ev-api-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ssh-keys/:id', [
  'headers' => [
    'ev-access-token' => '',
    'ev-api-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ssh-keys/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ssh-keys/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'ev-api-key' => '',
  'ev-access-token' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ssh-keys/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("ev-api-key", "")
$headers.Add("ev-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ssh-keys/:id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'ev-api-key': "",
    'ev-access-token': ""
}

conn.request("GET", "/baseUrl/ssh-keys/:id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ssh-keys/:id"

headers = {
    "ev-api-key": "",
    "ev-access-token": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ssh-keys/:id"

response <- VERB("GET", url, add_headers('ev-api-key' = '', 'ev-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ssh-keys/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["ev-api-key"] = ''
request["ev-access-token"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ssh-keys/:id') do |req|
  req.headers['ev-api-key'] = ''
  req.headers['ev-access-token'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ssh-keys/:id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("ev-api-key", "".parse().unwrap());
    headers.insert("ev-access-token", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/ssh-keys/:id \
  ev-access-token:'' \
  ev-api-key:''

wget --quiet \
  --method GET \
  --header 'ev-api-key: ' \
  --header 'ev-access-token: ' \
  --output-document \
  - {{baseUrl}}/ssh-keys/:id

import Foundation

let headers = [
  "ev-api-key": "",
  "ev-access-token": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ssh-keys/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()